Universal (isomorphic) JavaScript support for Angular 2.
* NodeJS :: Universal Starter repo
* ASP.NET Core :: Universal Starter repo
Manage your application lifecycle and serialize changes while on the server to be sent to the client.
Angular 2 Universal Patterns - ng-conf, May 2016
Angular Universal Source Code - ReadTheSource, January 2016
Full Stack Angular 2 - AngularConnect, Oct 2015
Angular 2 Server Rendering - Angular U, July 2015
Control server-rendered page and transfer state before client-side web app loads to the client-side-app.
When building Universal components in Angular 2 there are a few things to keep in mind.
Note: Universal currently only works with
router-deprecated
nativeElement directly. Use the Renderer. We do this to ensure that in any environment we're able to change our view.constructor(element: ElementRef, renderer: Renderer) {
renderer.setElementStyle(element.nativeElement, 'font-size', 'x-large');
}
navigator or document. Anything outside of Angular will not be detected when serializing your application into html. If you need access to these types please consider using DOM from "angular2/src/platform/dom/dom_adapter"url in img tag. For our native <img src=""> element the src attribute is reflected as the src property of the element type HTMLImageElement. We believe that using the word "universal" is correct when referring to a JavaScript Application that runs in more environments than the browser. (inspired by Universal JavaScript)
The Storage abstract class of the Web Storage API provides access to local storage for a particular domain.
An abstract service that can be used to get and set the title of a current HTML document.
Response {@link EventEmitter} which emits a single {@link Response} value on load event of
XMLHttpRequest.
Warn the developer about direct access to Window props
The property being accessed
Performs animations if necessary
If animations are necessary, performs animations then removes the element; otherwise, it just removes the element.
An array of providers that should be passed into application() when bootstrapping a component.
Dispatch an event on the document
Get the caret position within a given node. Some hackery in here to make sure this works in all browsers
These are global events that get passed around. Currently we use the document to do this.
Add event listener at window level
Remove a node since we are done with it
Set caret position in a given node
Loop through node events and add listeners
For a given node, add an event listener based on the given attribute. The attribute must match the Angular pattern for event handlers (i.e. either (event)='blah()' or on-event='blah'
Loop through replay strategies and call replayEvents functions. In most cases there will be only one replay strategy, but users may want to add multiple in some cases with the remaining events from one feeding into the next. Note that as with startListening() above, there are very little safety checks here in getting the replayEvents fn because those checks are in normalize.ts.
Prepare for freeze by adding elements to the DOM and adding an event handler
This listen strategy will look for a specific attribute which contains all the elements that a given element is listening to. For ex.
This is function called at each node while walking DOM. Will add node event if events defined on element.
This listen strategy will look for a specific attribute which contains all the elements that a given element is listening to.
This is from Crockford to walk the DOM (http: //whlp.ly/1Ii6YbR). Recursively walk DOM tree and execute input param function at each node.
This listen strategy uses a list of selectors maped to events. For example: { 'input[type="text"],textarea': ['focusin', 'focusout'], 'button': ['click'] }
Idea here is simple. If debugging turned on and this module exists, we log various things that happen in preboot. The calling code only references a number (keys in logMap) to a handling function. By doing this, we are able to cut down on the amount of logging code in preboot when no in debug mode.
Once bootstrap has completed, we replay events, switch buffer and then cleanup
Initialization is really simple. Just save the options and set the window object. Most stuff happens with start() * To call multiple times like init('app1', {}), init('app2', {})
Get function to run once window has loaded
Resume the completion process; if complete already called, call it again right away
Start preboot by starting to record events
this replay strategy assumes that the browser did not blow away the server generated HTML and that the elements in memory for preboot can be used to replay the events.
any events that could not be replayed for whatever reason are returned.
This replay strategy assumes that the browser completely re-rendered the page so reboot will need to find the element in the new browser rendered DOM that matches the element it has in memory.
Any events that could not be replayed for whatever reason are returned.
Generate browser code as a string for preboot based on the input options
Generate browser code as a readable stream for preboot based on the input options
We want to use the browserify ignore functionality so that any code modules that are not being used are stubbed out. So, for example, if in the preboot options the only listen strategy is selectors, then the event_bindings and attributes strategies will be stubbed out (meaing the refs will be {})
Normalize options so user can enter shorthand and it is expanded as appropriate for the browser code
Make sure freeze options are array of FreezeStrategy objects. We have a set of base styles that are used for freeze (i.e. for overaly and spinner), but these can be overriden
Make sure that the listen option is an array of ListenStrategy objects so client side doesn't need to worry about conversions
Just set default pauseEvent if doesn't exist
Presets are modifications to options. In the future, we may be simple presets like 'angular' which add all the listeners and replay.
Make sure replay options are array of ReplayStrategy objects. So, callers can just pass in simple string, but converted to an array before passed into client side preboot.
Set default resumeEvent if doesn't exist
Stringify an object and include functions
Applies a set of decorators to a target object.
An array of decorators.
The target object.
The result of applying the provided decorators.
Applies a set of decorators to a property of a target object.
An array of decorators.
The target object.
(Optional) The property key to decorate.
A property descriptor
Define a unique metadata entry on the target.
A key used to store and retrieve metadata.
A value that contains attached metadata.
The target object on which to define metadata.
Define a unique metadata entry on the target.
A key used to store and retrieve metadata.
A value that contains attached metadata.
The target object on which to define metadata.
(Optional) The property key for the target.
Deletes the metadata entry from the target object with the provided key.
A key used to store and retrieve metadata.
The target object on which the metadata is defined.
true if the metadata entry was found and deleted; otherwise, false.
Deletes the metadata entry from the target object with the provided key.
A key used to store and retrieve metadata.
The target object on which the metadata is defined.
(Optional) The property key for the target.
true if the metadata entry was found and deleted; otherwise, false.
Gets the metadata value for the provided metadata key on the target object or its prototype chain.
A key used to store and retrieve metadata.
The target object on which the metadata is defined.
The metadata value for the metadata key if found; otherwise, undefined.
Gets the metadata value for the provided metadata key on the target object or its prototype chain.
A key used to store and retrieve metadata.
The target object on which the metadata is defined.
(Optional) The property key for the target.
The metadata value for the metadata key if found; otherwise, undefined.
Gets the metadata keys defined on the target object or its prototype chain.
The target object on which the metadata is defined.
An array of unique metadata keys.
Gets the metadata keys defined on the target object or its prototype chain.
The target object on which the metadata is defined.
(Optional) The property key for the target.
An array of unique metadata keys.
Gets the metadata value for the provided metadata key on the target object.
A key used to store and retrieve metadata.
The target object on which the metadata is defined.
The metadata value for the metadata key if found; otherwise, undefined.
Gets the metadata value for the provided metadata key on the target object.
A key used to store and retrieve metadata.
The target object on which the metadata is defined.
(Optional) The property key for the target.
The metadata value for the metadata key if found; otherwise, undefined.
Gets the unique metadata keys defined on the target object.
The target object on which the metadata is defined.
An array of unique metadata keys.
Gets the unique metadata keys defined on the target object.
The target object on which the metadata is defined.
(Optional) The property key for the target.
An array of unique metadata keys.
Gets a value indicating whether the target object or its prototype chain has the provided metadata key defined.
A key used to store and retrieve metadata.
The target object on which the metadata is defined.
true if the metadata key was defined on the target object or its prototype chain; otherwise, false.
Gets a value indicating whether the target object or its prototype chain has the provided metadata key defined.
A key used to store and retrieve metadata.
The target object on which the metadata is defined.
(Optional) The property key for the target.
true if the metadata key was defined on the target object or its prototype chain; otherwise, false.
Gets a value indicating whether the target object has the provided metadata key defined.
A key used to store and retrieve metadata.
The target object on which the metadata is defined.
true if the metadata key was defined on the target object; otherwise, false.
Gets a value indicating whether the target object has the provided metadata key defined.
A key used to store and retrieve metadata.
The target object on which the metadata is defined.
(Optional) The property key for the target.
true if the metadata key was defined on the target object; otherwise, false.
A default metadata decorator factory that can be used on a class, class member, or parameter.
The key for the metadata entry.
The value for the metadata entry.
A decorator function.
a handler for each value emitted by the observable
a promise that either resolves on observable completion or rejects with the handled error
Registers handlers for handling emitted values, error and completions from the observable, and executes the observable's subscriber function, which will take action to set up the underlying data stream
(optional) either an observer defining all functions to be called, or the first of three possible handlers, which is the handler for each value emitted from the observable.
(optional) a handler for a terminal event resulting from an error. If no error handler is provided, the error will be thrown as unhandled
(optional) a handler for a terminal event resulting from successful completion.
a subscription reference to the registered handlers
a handler for each value emitted by the observable
a promise that either resolves on observable completion or rejects with the handled error
Registers handlers for handling emitted values, error and completions from the observable, and executes the observable's subscriber function, which will take action to set up the underlying data stream
(optional) either an observer defining all functions to be called, or the first of three possible handlers, which is the handler for each value emitted from the observable.
(optional) a handler for a terminal event resulting from an error. If no error handler is provided, the error will be thrown as unhandled
(optional) a handler for a terminal event resulting from successful completion.
a subscription reference to the registered handlers
We need this JSDoc comment for affecting ESDoc.
A flag to indicate whether this Subscription has already been unsubscribed.
Adds a tear down to be called during the unsubscribe() of this Subscription.
If the tear down being added is a subscription that is already
unsubscribed, is the same reference add is being called on, or is
Subscription.EMPTY, it will not be added.
If this subscription is already in an isUnsubscribed state, the passed
tear down logic will be executed immediately.
The additional logic to execute on teardown.
Returns the Subscription used or created to be
added to the inner subscriptions list. This Subscription can be used with
remove() to remove the passed teardown logic from the inner subscriptions
list.
The Observer callback to receive a valueless notification of type
complete from the Observable. Notifies the Observer that the Observable
has finished sending push-based notifications.
The Observer callback to receive notifications of type next from
the Observable, with a value. The Observable may call this method 0 or more
times.
Removes a Subscription from the internal list of subscriptions that will unsubscribe during the unsubscribe process of this Subscription.
The subscription to remove.
A static factory for a Subscriber, given a (potentially partial) definition of an Observer.
A Subscriber wrapping the (partially defined) Observer represented by the given arguments.
We need this JSDoc comment for affecting ESDoc.
Creates a new Observable that will execute the specified function when a Subscriber subscribes to it.
Creates an Observable with custom logic given in
the subscribe function.

create converts a subscribe function to an actual Observable. This is
equivalent to calling the Observable constructor. Write the subscribe
function so that it behaves as an Observable: It should invoke the
Subscriber's next, error, and complete methods following the
Observable Contract. A well-formed Observable must invoke either the
Subscriber's complete method exactly once or its error method exactly
once, and invoke nothing else thereafter.
Most of the times you should not need to use create because existing
creation operators (together with instance combination operators) allow you
to create an Observable for most of the use cases. However, create is
low-level and is able to create any Observable.
An Observable that, when subscribed, will execute the specified function.
An interface for a consumer of push-based notifications delivered by an Observable.
interface Observer<T> {
isUnsubscribed?: boolean;
next: (value: T) => void;
error: (err: any) => void;
complete: () => void;
}
An object conforming to the Observer interface is usually
given to the observable.subscribe(observer) method, and the Observable will
call the Observer's next(value) method to provide notifications. A
well-behaved Observable will call an Observer's complete() method exactly
once or the Observer's error(err) method exactly once, as the last
notification delivered.
An optional flag to indicate whether this Observer, when used as a subscriber, has already been unsubscribed from its Observable.
The callback to receive a valueless notification of type complete from
the Observable. Notifies the Observer that the Observable has finished
sending push-based notifications.
The callback to receive notifications of type error from the Observable,
with an attached Error. Notifies the Observer that the Observable
has experienced an error condition.
The error exception.
The callback to receive notifications of type next from the Observable,
with a value. The Observable may call this method 0 or more times.
The next value.
An execution context and a data structure to order tasks and schedule their
execution. Provides a notion of (potentially virtual) time, through the
now() getter method.
Each unit of work in a Scheduler is called an Action.
interface Scheduler {
now(): number;
schedule(work, delay?, state?): Subscription;
flush(): void;
active: boolean;
actions: Action[];
scheduledId: number;
}
The queue of scheduled actions as an array.
A flag to indicate whether the Scheduler is currently executing a batch of queued actions.
An internal ID used to track the latest asynchronous task such as those
coming from setTimeout, setInterval, requestAnimationFrame, and
others.
Prompt the Scheduler to execute all of its queued actions, therefore clearing its queue.
A getter method that returns a number representing the current time (at the time this function was called) according to the scheduler's own internal clock.
A number that represents the current time. May or may not have a relation to wall-clock time. May or may not refer to a time unit (e.g. milliseconds).
Schedules a function, work, for execution. May happen at some point in
the future, according to the delay parameter, if specified. May be passed
some context object, state, which will be passed to the work function.
The given arguments will be processed an stored as an Action object in a queue of actions.
A function representing a task, or some unit of work to be executed by the Scheduler.
A subscription in order to be able to unsubscribe the scheduled work.
Represents a push-based event or value that an Observable can emit.
This class is particularly useful for operators that manage notifications,
like materialize, dematerialize, observeOn, and
others. Besides wrapping the actual delivered value, it also annotates it
with metadata of, for instance, what type of push message it is (next,
error, or complete).
Takes an Observer or its individual callback functions, and calls observe
or do methods accordingly.
An Observer or
the next callback.
Given some Observer callbacks, deliver the value represented by the current Notification to the correctly corresponding callback.
An Observer next callback.
Delivers to the given observer the value wrapped by this Notification.
Returns a simple Observable that just delivers the notification represented by this Notification instance.
A shortcut to create a Notification instance of the type complete.
The valueless "complete" Notification.
A shortcut to create a Notification instance of the type error from a
given error.
The "error" Notification representing the argument.
A shortcut to create a Notification instance of the type next from a
given value.
The next value.
The "next" Notification representing the argument.
A representation of any set of values over any amount of time. This the most basic building block of RxJS.
the function that is called when the Observable is
initially subscribed to. This function is given a Subscriber, to which new values
can be nexted, or an error method can be called to raise an error, or
complete can be called to notify of a successful completion.
An interop point defined by the es7-observable spec https://github.com/zenparsing/es-observable
this instance of the observable
a handler for each value emitted by the observable
a promise that either resolves on observable completion or rejects with the handled error
Creates a new Observable, with this Observable as the source, and the passed operator defined as the new observable's operator.
the operator defining the operation to take on the observable
a new observable with the Operator applied
Registers handlers for handling emitted values, error and completions from the observable, and executes the observable's subscriber function, which will take action to set up the underlying data stream
(optional) either an observer defining all functions to be called, or the first of three possible handlers, which is the handler for each value emitted from the observable.
(optional) a handler for a terminal event resulting from an error. If no error handler is provided, the error will be thrown as unhandled
(optional) a handler for a terminal event resulting from successful completion.
a subscription reference to the registered handlers
Creates a new cold Observable by calling the Observable constructor
a new cold observable
We need this JSDoc comment for affecting ESDoc.
A flag to indicate whether this Subscription has already been unsubscribed.
Adds a tear down to be called during the unsubscribe() of this Subscription.
If the tear down being added is a subscription that is already
unsubscribed, is the same reference add is being called on, or is
Subscription.EMPTY, it will not be added.
If this subscription is already in an isUnsubscribed state, the passed
tear down logic will be executed immediately.
The additional logic to execute on teardown.
Returns the Subscription used or created to be
added to the inner subscriptions list. This Subscription can be used with
remove() to remove the passed teardown logic from the inner subscriptions
list.
The Observer callback to receive a valueless notification of type
complete from the Observable. Notifies the Observer that the Observable
has finished sending push-based notifications.
The Observer callback to receive notifications of type next from
the Observable, with a value. The Observable may call this method 0 or more
times.
Removes a Subscription from the internal list of subscriptions that will unsubscribe during the unsubscribe process of this Subscription.
The subscription to remove.
A static factory for a Subscriber, given a (potentially partial) definition of an Observer.
A Subscriber wrapping the (partially defined) Observer represented by the given arguments.
a handler for each value emitted by the observable
a promise that either resolves on observable completion or rejects with the handled error
Registers handlers for handling emitted values, error and completions from the observable, and executes the observable's subscriber function, which will take action to set up the underlying data stream
(optional) either an observer defining all functions to be called, or the first of three possible handlers, which is the handler for each value emitted from the observable.
(optional) a handler for a terminal event resulting from an error. If no error handler is provided, the error will be thrown as unhandled
(optional) a handler for a terminal event resulting from successful completion.
a subscription reference to the registered handlers
a handler for each value emitted by the observable
a promise that either resolves on observable completion or rejects with the handled error
Registers handlers for handling emitted values, error and completions from the observable, and executes the observable's subscriber function, which will take action to set up the underlying data stream
(optional) either an observer defining all functions to be called, or the first of three possible handlers, which is the handler for each value emitted from the observable.
(optional) a handler for a terminal event resulting from an error. If no error handler is provided, the error will be thrown as unhandled
(optional) a handler for a terminal event resulting from successful completion.
a subscription reference to the registered handlers
We need this JSDoc comment for affecting ESDoc.
An interop point defined by the es7-observable spec https://github.com/zenparsing/es-observable
this instance of the observable
a handler for each value emitted by the observable
a promise that either resolves on observable completion or rejects with the handled error
Creates a new Observable, with this Observable as the source, and the passed operator defined as the new observable's operator.
the operator defining the operation to take on the observable
a new observable with the Operator applied
Registers handlers for handling emitted values, error and completions from the observable, and executes the observable's subscriber function, which will take action to set up the underlying data stream
(optional) either an observer defining all functions to be called, or the first of three possible handlers, which is the handler for each value emitted from the observable.
(optional) a handler for a terminal event resulting from an error. If no error handler is provided, the error will be thrown as unhandled
(optional) a handler for a terminal event resulting from successful completion.
a subscription reference to the registered handlers
Creates a new cold Observable by calling the Observable constructor
a new cold observable
We need this JSDoc comment for affecting ESDoc.
Adds a tear down to be called during the unsubscribe() of this Subscription.
If the tear down being added is a subscription that is already
unsubscribed, is the same reference add is being called on, or is
Subscription.EMPTY, it will not be added.
If this subscription is already in an isUnsubscribed state, the passed
tear down logic will be executed immediately.
The additional logic to execute on teardown.
Returns the Subscription used or created to be
added to the inner subscriptions list. This Subscription can be used with
remove() to remove the passed teardown logic from the inner subscriptions
list.
Removes a Subscription from the internal list of subscriptions that will unsubscribe during the unsubscribe process of this Subscription.
The subscription to remove.
We need this JSDoc comment for affecting ESDoc.
A flag to indicate whether this Subscription has already been unsubscribed.
Adds a tear down to be called during the unsubscribe() of this Subscription.
If the tear down being added is a subscription that is already
unsubscribed, is the same reference add is being called on, or is
Subscription.EMPTY, it will not be added.
If this subscription is already in an isUnsubscribed state, the passed
tear down logic will be executed immediately.
The additional logic to execute on teardown.
Returns the Subscription used or created to be
added to the inner subscriptions list. This Subscription can be used with
remove() to remove the passed teardown logic from the inner subscriptions
list.
Removes a Subscription from the internal list of subscriptions that will unsubscribe during the unsubscribe process of this Subscription.
The subscription to remove.
A static factory for a Subscriber, given a (potentially partial) definition of an Observer.
A Subscriber wrapping the (partially defined) Observer represented by the given arguments.
Implements the Observer interface and extends the
Subscription class. While the Observer is the public API for
consuming the values of an Observable, all Observers get converted to
a Subscriber, in order to provide Subscription-like capabilities such as
unsubscribe. Subscriber is a common type in RxJS, and crucial for
implementing operators, but it is rarely used as a public API.
A flag to indicate whether this Subscription has already been unsubscribed.
Adds a tear down to be called during the unsubscribe() of this Subscription.
If the tear down being added is a subscription that is already
unsubscribed, is the same reference add is being called on, or is
Subscription.EMPTY, it will not be added.
If this subscription is already in an isUnsubscribed state, the passed
tear down logic will be executed immediately.
The additional logic to execute on teardown.
Returns the Subscription used or created to be
added to the inner subscriptions list. This Subscription can be used with
remove() to remove the passed teardown logic from the inner subscriptions
list.
The Observer callback to receive a valueless notification of type
complete from the Observable. Notifies the Observer that the Observable
has finished sending push-based notifications.
The Observer callback to receive notifications of type next from
the Observable, with a value. The Observable may call this method 0 or more
times.
Removes a Subscription from the internal list of subscriptions that will unsubscribe during the unsubscribe process of this Subscription.
The subscription to remove.
A static factory for a Subscriber, given a (potentially partial) definition of an Observer.
A Subscriber wrapping the (partially defined) Observer represented by the given arguments.
Represents a disposable resource, such as the execution of an Observable. A
Subscription has one important method, unsubscribe, that takes no argument
and just disposes the resource held by the subscription.
Additionally, subscriptions may be grouped together through the add()
method, which will attach a child Subscription to the current Subscription.
When a Subscription is unsubscribed, all its children (and its grandchildren)
will be unsubscribed as well.
A flag to indicate whether this Subscription has already been unsubscribed.
Adds a tear down to be called during the unsubscribe() of this Subscription.
If the tear down being added is a subscription that is already
unsubscribed, is the same reference add is being called on, or is
Subscription.EMPTY, it will not be added.
If this subscription is already in an isUnsubscribed state, the passed
tear down logic will be executed immediately.
The additional logic to execute on teardown.
Returns the Subscription used or created to be
added to the inner subscriptions list. This Subscription can be used with
remove() to remove the passed teardown logic from the inner subscriptions
list.
Removes a Subscription from the internal list of subscriptions that will unsubscribe during the unsubscribe process of this Subscription.
The subscription to remove.
Disposes the resources held by the subscription. May, for instance, cancel an ongoing Observable execution or cancel any other type of work that started when the Subscription was created.
We need this JSDoc comment for affecting ESDoc.
An interop point defined by the es7-observable spec https://github.com/zenparsing/es-observable
this instance of the observable
a handler for each value emitted by the observable
a promise that either resolves on observable completion or rejects with the handled error
Creates a new Observable, with this Observable as the source, and the passed operator defined as the new observable's operator.
the operator defining the operation to take on the observable
a new observable with the Operator applied
Registers handlers for handling emitted values, error and completions from the observable, and executes the observable's subscriber function, which will take action to set up the underlying data stream
(optional) either an observer defining all functions to be called, or the first of three possible handlers, which is the handler for each value emitted from the observable.
(optional) a handler for a terminal event resulting from an error. If no error handler is provided, the error will be thrown as unhandled
(optional) a handler for a terminal event resulting from successful completion.
a subscription reference to the registered handlers
We need this JSDoc comment for affecting ESDoc.
An interop point defined by the es7-observable spec https://github.com/zenparsing/es-observable
this instance of the observable
a handler for each value emitted by the observable
a promise that either resolves on observable completion or rejects with the handled error
Creates a new Observable, with this Observable as the source, and the passed operator defined as the new observable's operator.
the operator defining the operation to take on the observable
a new observable with the Operator applied
Registers handlers for handling emitted values, error and completions from the observable, and executes the observable's subscriber function, which will take action to set up the underlying data stream
(optional) either an observer defining all functions to be called, or the first of three possible handlers, which is the handler for each value emitted from the observable.
(optional) a handler for a terminal event resulting from an error. If no error handler is provided, the error will be thrown as unhandled
(optional) a handler for a terminal event resulting from successful completion.
a subscription reference to the registered handlers
Creates an Observable that emits some values you specify as arguments, immediately one after the other, and then emits a complete notification.
Emits the arguments you provide, then completes.

This static operator is useful for creating a simple Observable that only
emits the arguments given, and the complete notification thereafter. It can
be used for composing with other Observables, such as with concat.
By default, it uses a null Scheduler, which means the next
notifications are sent synchronously, although with a different Scheduler
it is possible to determine when those notifications will be delivered.
An Observable that emits each given input value.
Creates an Observable that emits some values you specify as arguments, immediately one after the other, and then emits a complete notification.
Emits the arguments you provide, then completes.

This static operator is useful for creating a simple Observable that only
emits the arguments given, and the complete notification thereafter. It can
be used for composing with other Observables, such as with concat.
By default, it uses a null Scheduler, which means the next
notifications are sent synchronously, although with a different Scheduler
it is possible to determine when those notifications will be delivered.
An Observable that emits each given input value.
Creates an Observable that emits some values you specify as arguments, immediately one after the other, and then emits a complete notification.
Emits the arguments you provide, then completes.

This static operator is useful for creating a simple Observable that only
emits the arguments given, and the complete notification thereafter. It can
be used for composing with other Observables, such as with concat.
By default, it uses a null Scheduler, which means the next
notifications are sent synchronously, although with a different Scheduler
it is possible to determine when those notifications will be delivered.
An Observable that emits each given input value.
Creates an Observable that emits some values you specify as arguments, immediately one after the other, and then emits a complete notification.
Emits the arguments you provide, then completes.

This static operator is useful for creating a simple Observable that only
emits the arguments given, and the complete notification thereafter. It can
be used for composing with other Observables, such as with concat.
By default, it uses a null Scheduler, which means the next
notifications are sent synchronously, although with a different Scheduler
it is possible to determine when those notifications will be delivered.
An Observable that emits each given input value.
Creates an Observable that emits some values you specify as arguments, immediately one after the other, and then emits a complete notification.
Emits the arguments you provide, then completes.

This static operator is useful for creating a simple Observable that only
emits the arguments given, and the complete notification thereafter. It can
be used for composing with other Observables, such as with concat.
By default, it uses a null Scheduler, which means the next
notifications are sent synchronously, although with a different Scheduler
it is possible to determine when those notifications will be delivered.
An Observable that emits each given input value.
Creates an Observable that emits some values you specify as arguments, immediately one after the other, and then emits a complete notification.
Emits the arguments you provide, then completes.

This static operator is useful for creating a simple Observable that only
emits the arguments given, and the complete notification thereafter. It can
be used for composing with other Observables, such as with concat.
By default, it uses a null Scheduler, which means the next
notifications are sent synchronously, although with a different Scheduler
it is possible to determine when those notifications will be delivered.
An Observable that emits each given input value.
Creates an Observable that emits some values you specify as arguments, immediately one after the other, and then emits a complete notification.
Emits the arguments you provide, then completes.

This static operator is useful for creating a simple Observable that only
emits the arguments given, and the complete notification thereafter. It can
be used for composing with other Observables, such as with concat.
By default, it uses a null Scheduler, which means the next
notifications are sent synchronously, although with a different Scheduler
it is possible to determine when those notifications will be delivered.
An Observable that emits each given input value.
We need this JSDoc comment for affecting ESDoc.
An interop point defined by the es7-observable spec https://github.com/zenparsing/es-observable
this instance of the observable
a handler for each value emitted by the observable
a promise that either resolves on observable completion or rejects with the handled error
Creates a new Observable, with this Observable as the source, and the passed operator defined as the new observable's operator.
the operator defining the operation to take on the observable
a new observable with the Operator applied
Registers handlers for handling emitted values, error and completions from the observable, and executes the observable's subscriber function, which will take action to set up the underlying data stream
(optional) either an observer defining all functions to be called, or the first of three possible handlers, which is the handler for each value emitted from the observable.
(optional) a handler for a terminal event resulting from an error. If no error handler is provided, the error will be thrown as unhandled
(optional) a handler for a terminal event resulting from successful completion.
a subscription reference to the registered handlers
Converts a callback function to an observable sequence.
Function with a callback as the last parameter.
A selector which takes the arguments from the callback to produce a single item to yield on next.
a function which returns the Observable that corresponds to the callback.
Converts a callback function to an observable sequence.
Function with a callback as the last parameter.
A selector which takes the arguments from the callback to produce a single item to yield on next.
a function which returns the Observable that corresponds to the callback.
Converts a callback function to an observable sequence.
Function with a callback as the last parameter.
A selector which takes the arguments from the callback to produce a single item to yield on next.
a function which returns the Observable that corresponds to the callback.
Converts a callback function to an observable sequence.
Function with a callback as the last parameter.
A selector which takes the arguments from the callback to produce a single item to yield on next.
a function which returns the Observable that corresponds to the callback.
Converts a callback function to an observable sequence.
Function with a callback as the last parameter.
A selector which takes the arguments from the callback to produce a single item to yield on next.
a function which returns the Observable that corresponds to the callback.
Converts a callback function to an observable sequence.
Function with a callback as the last parameter.
A selector which takes the arguments from the callback to produce a single item to yield on next.
a function which returns the Observable that corresponds to the callback.
Converts a callback function to an observable sequence.
Function with a callback as the last parameter.
A selector which takes the arguments from the callback to produce a single item to yield on next.
a function which returns the Observable that corresponds to the callback.
Converts a callback function to an observable sequence.
Function with a callback as the last parameter.
A selector which takes the arguments from the callback to produce a single item to yield on next.
a function which returns the Observable that corresponds to the callback.
Converts a callback function to an observable sequence.
Function with a callback as the last parameter.
A selector which takes the arguments from the callback to produce a single item to yield on next.
a function which returns the Observable that corresponds to the callback.
Converts a callback function to an observable sequence.
Function with a callback as the last parameter.
A selector which takes the arguments from the callback to produce a single item to yield on next.
a function which returns the Observable that corresponds to the callback.
Converts a callback function to an observable sequence.
Function with a callback as the last parameter.
A selector which takes the arguments from the callback to produce a single item to yield on next.
a function which returns the Observable that corresponds to the callback.
Converts a callback function to an observable sequence.
Function with a callback as the last parameter.
A selector which takes the arguments from the callback to produce a single item to yield on next.
a function which returns the Observable that corresponds to the callback.
Converts a callback function to an observable sequence.
Function with a callback as the last parameter.
A selector which takes the arguments from the callback to produce a single item to yield on next.
a function which returns the Observable that corresponds to the callback.
Converts a callback function to an observable sequence.
Function with a callback as the last parameter.
A selector which takes the arguments from the callback to produce a single item to yield on next.
a function which returns the Observable that corresponds to the callback.
Converts a callback function to an observable sequence.
Function with a callback as the last parameter.
A selector which takes the arguments from the callback to produce a single item to yield on next.
a function which returns the Observable that corresponds to the callback.
Converts a callback function to an observable sequence.
Function with a callback as the last parameter.
A selector which takes the arguments from the callback to produce a single item to yield on next.
a function which returns the Observable that corresponds to the callback.
We need this JSDoc comment for affecting ESDoc.
An interop point defined by the es7-observable spec https://github.com/zenparsing/es-observable
this instance of the observable
a handler for each value emitted by the observable
a promise that either resolves on observable completion or rejects with the handled error
Creates a new Observable, with this Observable as the source, and the passed operator defined as the new observable's operator.
the operator defining the operation to take on the observable
a new observable with the Operator applied
Registers handlers for handling emitted values, error and completions from the observable, and executes the observable's subscriber function, which will take action to set up the underlying data stream
(optional) either an observer defining all functions to be called, or the first of three possible handlers, which is the handler for each value emitted from the observable.
(optional) a handler for a terminal event resulting from an error. If no error handler is provided, the error will be thrown as unhandled
(optional) a handler for a terminal event resulting from successful completion.
a subscription reference to the registered handlers
Converts a node callback to an Observable.
Converts a node callback to an Observable.
Converts a node callback to an Observable.
Converts a node callback to an Observable.
Converts a node callback to an Observable.
Converts a node callback to an Observable.
Converts a node callback to an Observable.
Converts a node callback to an Observable.
Converts a node callback to an Observable.
An interop point defined by the es7-observable spec https://github.com/zenparsing/es-observable
this instance of the observable
This method is opened for ConnectableSubscription.
Not to call from others.
a handler for each value emitted by the observable
a promise that either resolves on observable completion or rejects with the handled error
Creates a new Observable, with this Observable as the source, and the passed operator defined as the new observable's operator.
the operator defining the operation to take on the observable
a new observable with the Operator applied
Registers handlers for handling emitted values, error and completions from the observable, and executes the observable's subscriber function, which will take action to set up the underlying data stream
(optional) either an observer defining all functions to be called, or the first of three possible handlers, which is the handler for each value emitted from the observable.
(optional) a handler for a terminal event resulting from an error. If no error handler is provided, the error will be thrown as unhandled
(optional) a handler for a terminal event resulting from successful completion.
a subscription reference to the registered handlers
Creates a new cold Observable by calling the Observable constructor
a new cold observable
We need this JSDoc comment for affecting ESDoc.
A flag to indicate whether this Subscription has already been unsubscribed.
Adds a tear down to be called during the unsubscribe() of this Subscription.
If the tear down being added is a subscription that is already
unsubscribed, is the same reference add is being called on, or is
Subscription.EMPTY, it will not be added.
If this subscription is already in an isUnsubscribed state, the passed
tear down logic will be executed immediately.
The additional logic to execute on teardown.
Returns the Subscription used or created to be
added to the inner subscriptions list. This Subscription can be used with
remove() to remove the passed teardown logic from the inner subscriptions
list.
Removes a Subscription from the internal list of subscriptions that will unsubscribe during the unsubscribe process of this Subscription.
The subscription to remove.
Disposes the resources held by the subscription. May, for instance, cancel an ongoing Observable execution or cancel any other type of work that started when the Subscription was created.
We need this JSDoc comment for affecting ESDoc.
An interop point defined by the es7-observable spec https://github.com/zenparsing/es-observable
this instance of the observable
a handler for each value emitted by the observable
a promise that either resolves on observable completion or rejects with the handled error
Creates a new Observable, with this Observable as the source, and the passed operator defined as the new observable's operator.
the operator defining the operation to take on the observable
a new observable with the Operator applied
Registers handlers for handling emitted values, error and completions from the observable, and executes the observable's subscriber function, which will take action to set up the underlying data stream
(optional) either an observer defining all functions to be called, or the first of three possible handlers, which is the handler for each value emitted from the observable.
(optional) a handler for a terminal event resulting from an error. If no error handler is provided, the error will be thrown as unhandled
(optional) a handler for a terminal event resulting from successful completion.
a subscription reference to the registered handlers
Creates a new cold Observable by calling the Observable constructor
a new cold observable
We need this JSDoc comment for affecting ESDoc.
A flag to indicate whether this Subscription has already been unsubscribed.
Adds a tear down to be called during the unsubscribe() of this Subscription.
If the tear down being added is a subscription that is already
unsubscribed, is the same reference add is being called on, or is
Subscription.EMPTY, it will not be added.
If this subscription is already in an isUnsubscribed state, the passed
tear down logic will be executed immediately.
The additional logic to execute on teardown.
Returns the Subscription used or created to be
added to the inner subscriptions list. This Subscription can be used with
remove() to remove the passed teardown logic from the inner subscriptions
list.
The Observer callback to receive a valueless notification of type
complete from the Observable. Notifies the Observer that the Observable
has finished sending push-based notifications.
The Observer callback to receive notifications of type next from
the Observable, with a value. The Observable may call this method 0 or more
times.
Removes a Subscription from the internal list of subscriptions that will unsubscribe during the unsubscribe process of this Subscription.
The subscription to remove.
A static factory for a Subscriber, given a (potentially partial) definition of an Observer.
A Subscriber wrapping the (partially defined) Observer represented by the given arguments.
We need this JSDoc comment for affecting ESDoc.
An interop point defined by the es7-observable spec https://github.com/zenparsing/es-observable
this instance of the observable
a handler for each value emitted by the observable
a promise that either resolves on observable completion or rejects with the handled error
Creates a new Observable, with this Observable as the source, and the passed operator defined as the new observable's operator.
the operator defining the operation to take on the observable
a new observable with the Operator applied
Registers handlers for handling emitted values, error and completions from the observable, and executes the observable's subscriber function, which will take action to set up the underlying data stream
(optional) either an observer defining all functions to be called, or the first of three possible handlers, which is the handler for each value emitted from the observable.
(optional) a handler for a terminal event resulting from an error. If no error handler is provided, the error will be thrown as unhandled
(optional) a handler for a terminal event resulting from successful completion.
a subscription reference to the registered handlers
Creates an Observable that, on subscribe, calls an Observable factory to make an Observable for each new Observer.
Creates the Observable lazily, that is, only when it is subscribed.

defer allows you to create the Observable only when the Observer
subscribes, and create a fresh Observable for each Observer. It waits until
an Observer subscribes to it, and then it generates an Observable,
typically with an Observable factory function. It does this afresh for each
subscriber, so although each subscriber may think it is subscribing to the
same Observable, in fact each subscriber gets its own individual
Observable.
The Observable factory function to invoke for each Observer that subscribes to the output Observable. May also return a Promise, which will be converted on the fly to an Observable.
An Observable whose Observers' subscriptions trigger an invocation of the given Observable factory function.
A flag to indicate whether this Subscription has already been unsubscribed.
Adds a tear down to be called during the unsubscribe() of this Subscription.
If the tear down being added is a subscription that is already
unsubscribed, is the same reference add is being called on, or is
Subscription.EMPTY, it will not be added.
If this subscription is already in an isUnsubscribed state, the passed
tear down logic will be executed immediately.
The additional logic to execute on teardown.
Returns the Subscription used or created to be
added to the inner subscriptions list. This Subscription can be used with
remove() to remove the passed teardown logic from the inner subscriptions
list.
The Observer callback to receive a valueless notification of type
complete from the Observable. Notifies the Observer that the Observable
has finished sending push-based notifications.
The Observer callback to receive notifications of type next from
the Observable, with a value. The Observable may call this method 0 or more
times.
Removes a Subscription from the internal list of subscriptions that will unsubscribe during the unsubscribe process of this Subscription.
The subscription to remove.
A static factory for a Subscriber, given a (potentially partial) definition of an Observer.
A Subscriber wrapping the (partially defined) Observer represented by the given arguments.
We need this JSDoc comment for affecting ESDoc.
An interop point defined by the es7-observable spec https://github.com/zenparsing/es-observable
this instance of the observable
a handler for each value emitted by the observable
a promise that either resolves on observable completion or rejects with the handled error
Creates a new Observable, with this Observable as the source, and the passed operator defined as the new observable's operator.
the operator defining the operation to take on the observable
a new observable with the Operator applied
Registers handlers for handling emitted values, error and completions from the observable, and executes the observable's subscriber function, which will take action to set up the underlying data stream
(optional) either an observer defining all functions to be called, or the first of three possible handlers, which is the handler for each value emitted from the observable.
(optional) a handler for a terminal event resulting from an error. If no error handler is provided, the error will be thrown as unhandled
(optional) a handler for a terminal event resulting from successful completion.
a subscription reference to the registered handlers
Creates an Observable that emits no items to the Observer and immediately emits a complete notification.
Just emits 'complete', and nothing else.

This static operator is useful for creating a simple Observable that only emits the complete notification. It can be used for composing with other Observables, such as in a mergeMap.
An "empty" Observable: emits only the complete notification.
We need this JSDoc comment for affecting ESDoc.
An interop point defined by the es7-observable spec https://github.com/zenparsing/es-observable
this instance of the observable
a handler for each value emitted by the observable
a promise that either resolves on observable completion or rejects with the handled error
Creates a new Observable, with this Observable as the source, and the passed operator defined as the new observable's operator.
the operator defining the operation to take on the observable
a new observable with the Operator applied
Registers handlers for handling emitted values, error and completions from the observable, and executes the observable's subscriber function, which will take action to set up the underlying data stream
(optional) either an observer defining all functions to be called, or the first of three possible handlers, which is the handler for each value emitted from the observable.
(optional) a handler for a terminal event resulting from an error. If no error handler is provided, the error will be thrown as unhandled
(optional) a handler for a terminal event resulting from successful completion.
a subscription reference to the registered handlers
Creates an Observable that emits no items to the Observer and immediately emits an error notification.
Just emits 'error', and nothing else.

This static operator is useful for creating a simple Observable that only emits the error notification. It can be used for composing with other Observables, such as in a mergeMap.
The particular Error to pass to the error notification.
An error Observable: emits only the error notification using the given error argument.
We need this JSDoc comment for affecting ESDoc.
An interop point defined by the es7-observable spec https://github.com/zenparsing/es-observable
this instance of the observable
a handler for each value emitted by the observable
a promise that either resolves on observable completion or rejects with the handled error
Creates a new Observable, with this Observable as the source, and the passed operator defined as the new observable's operator.
the operator defining the operation to take on the observable
a new observable with the Operator applied
Registers handlers for handling emitted values, error and completions from the observable, and executes the observable's subscriber function, which will take action to set up the underlying data stream
(optional) either an observer defining all functions to be called, or the first of three possible handlers, which is the handler for each value emitted from the observable.
(optional) a handler for a terminal event resulting from an error. If no error handler is provided, the error will be thrown as unhandled
(optional) a handler for a terminal event resulting from successful completion.
a subscription reference to the registered handlers
We need this JSDoc comment for affecting ESDoc.
A flag to indicate whether this Subscription has already been unsubscribed.
Adds a tear down to be called during the unsubscribe() of this Subscription.
If the tear down being added is a subscription that is already
unsubscribed, is the same reference add is being called on, or is
Subscription.EMPTY, it will not be added.
If this subscription is already in an isUnsubscribed state, the passed
tear down logic will be executed immediately.
The additional logic to execute on teardown.
Returns the Subscription used or created to be
added to the inner subscriptions list. This Subscription can be used with
remove() to remove the passed teardown logic from the inner subscriptions
list.
The Observer callback to receive a valueless notification of type
complete from the Observable. Notifies the Observer that the Observable
has finished sending push-based notifications.
The Observer callback to receive notifications of type next from
the Observable, with a value. The Observable may call this method 0 or more
times.
Removes a Subscription from the internal list of subscriptions that will unsubscribe during the unsubscribe process of this Subscription.
The subscription to remove.
A static factory for a Subscriber, given a (potentially partial) definition of an Observer.
A Subscriber wrapping the (partially defined) Observer represented by the given arguments.
We need this JSDoc comment for affecting ESDoc.
An interop point defined by the es7-observable spec https://github.com/zenparsing/es-observable
this instance of the observable
a handler for each value emitted by the observable
a promise that either resolves on observable completion or rejects with the handled error
Creates a new Observable, with this Observable as the source, and the passed operator defined as the new observable's operator.
the operator defining the operation to take on the observable
a new observable with the Operator applied
Registers handlers for handling emitted values, error and completions from the observable, and executes the observable's subscriber function, which will take action to set up the underlying data stream
(optional) either an observer defining all functions to be called, or the first of three possible handlers, which is the handler for each value emitted from the observable.
(optional) a handler for a terminal event resulting from an error. If no error handler is provided, the error will be thrown as unhandled
(optional) a handler for a terminal event resulting from successful completion.
a subscription reference to the registered handlers
We need this JSDoc comment for affecting ESDoc.
An interop point defined by the es7-observable spec https://github.com/zenparsing/es-observable
this instance of the observable
a handler for each value emitted by the observable
a promise that either resolves on observable completion or rejects with the handled error
Creates a new Observable, with this Observable as the source, and the passed operator defined as the new observable's operator.
the operator defining the operation to take on the observable
a new observable with the Operator applied
Registers handlers for handling emitted values, error and completions from the observable, and executes the observable's subscriber function, which will take action to set up the underlying data stream
(optional) either an observer defining all functions to be called, or the first of three possible handlers, which is the handler for each value emitted from the observable.
(optional) a handler for a terminal event resulting from an error. If no error handler is provided, the error will be thrown as unhandled
(optional) a handler for a terminal event resulting from successful completion.
a subscription reference to the registered handlers
We need this JSDoc comment for affecting ESDoc.
An interop point defined by the es7-observable spec https://github.com/zenparsing/es-observable
this instance of the observable
a handler for each value emitted by the observable
a promise that either resolves on observable completion or rejects with the handled error
Creates a new Observable, with this Observable as the source, and the passed operator defined as the new observable's operator.
the operator defining the operation to take on the observable
a new observable with the Operator applied
Registers handlers for handling emitted values, error and completions from the observable, and executes the observable's subscriber function, which will take action to set up the underlying data stream
(optional) either an observer defining all functions to be called, or the first of three possible handlers, which is the handler for each value emitted from the observable.
(optional) a handler for a terminal event resulting from an error. If no error handler is provided, the error will be thrown as unhandled
(optional) a handler for a terminal event resulting from successful completion.
a subscription reference to the registered handlers
We need this JSDoc comment for affecting ESDoc.
An interop point defined by the es7-observable spec https://github.com/zenparsing/es-observable
this instance of the observable
a handler for each value emitted by the observable
a promise that either resolves on observable completion or rejects with the handled error
Creates a new Observable, with this Observable as the source, and the passed operator defined as the new observable's operator.
the operator defining the operation to take on the observable
a new observable with the Operator applied
Registers handlers for handling emitted values, error and completions from the observable, and executes the observable's subscriber function, which will take action to set up the underlying data stream
(optional) either an observer defining all functions to be called, or the first of three possible handlers, which is the handler for each value emitted from the observable.
(optional) a handler for a terminal event resulting from an error. If no error handler is provided, the error will be thrown as unhandled
(optional) a handler for a terminal event resulting from successful completion.
a subscription reference to the registered handlers
A flag to indicate whether this Subscription has already been unsubscribed.
Adds a tear down to be called during the unsubscribe() of this Subscription.
If the tear down being added is a subscription that is already
unsubscribed, is the same reference add is being called on, or is
Subscription.EMPTY, it will not be added.
If this subscription is already in an isUnsubscribed state, the passed
tear down logic will be executed immediately.
The additional logic to execute on teardown.
Returns the Subscription used or created to be
added to the inner subscriptions list. This Subscription can be used with
remove() to remove the passed teardown logic from the inner subscriptions
list.
The Observer callback to receive a valueless notification of type
complete from the Observable. Notifies the Observer that the Observable
has finished sending push-based notifications.
The Observer callback to receive notifications of type next from
the Observable, with a value. The Observable may call this method 0 or more
times.
Removes a Subscription from the internal list of subscriptions that will unsubscribe during the unsubscribe process of this Subscription.
The subscription to remove.
A static factory for a Subscriber, given a (potentially partial) definition of an Observer.
A Subscriber wrapping the (partially defined) Observer represented by the given arguments.
We need this JSDoc comment for affecting ESDoc.
An interop point defined by the es7-observable spec https://github.com/zenparsing/es-observable
this instance of the observable
a handler for each value emitted by the observable
a promise that either resolves on observable completion or rejects with the handled error
Creates a new Observable, with this Observable as the source, and the passed operator defined as the new observable's operator.
the operator defining the operation to take on the observable
a new observable with the Operator applied
Registers handlers for handling emitted values, error and completions from the observable, and executes the observable's subscriber function, which will take action to set up the underlying data stream
(optional) either an observer defining all functions to be called, or the first of three possible handlers, which is the handler for each value emitted from the observable.
(optional) a handler for a terminal event resulting from an error. If no error handler is provided, the error will be thrown as unhandled
(optional) a handler for a terminal event resulting from successful completion.
a subscription reference to the registered handlers
Creates an Observable that emits sequential numbers every specified interval of time, on a specified Scheduler.
Emits incremental numbers periodically in time.

interval returns an Observable that emits an infinite sequence of
ascending integers, with a constant interval of time of your choosing
between those emissions. The first emission is not sent immediately, but
only after the first period has passed. By default, this operator uses the
async Scheduler to provide a notion of time, but you may pass any
Scheduler to it.
An Observable that emits a sequential number each time interval.
We need this JSDoc comment for affecting ESDoc.
An interop point defined by the es7-observable spec https://github.com/zenparsing/es-observable
this instance of the observable
a handler for each value emitted by the observable
a promise that either resolves on observable completion or rejects with the handled error
Creates a new Observable, with this Observable as the source, and the passed operator defined as the new observable's operator.
the operator defining the operation to take on the observable
a new observable with the Operator applied
Registers handlers for handling emitted values, error and completions from the observable, and executes the observable's subscriber function, which will take action to set up the underlying data stream
(optional) either an observer defining all functions to be called, or the first of three possible handlers, which is the handler for each value emitted from the observable.
(optional) a handler for a terminal event resulting from an error. If no error handler is provided, the error will be thrown as unhandled
(optional) a handler for a terminal event resulting from successful completion.
a subscription reference to the registered handlers
We need this JSDoc comment for affecting ESDoc.
An interop point defined by the es7-observable spec https://github.com/zenparsing/es-observable
this instance of the observable
a handler for each value emitted by the observable
a promise that either resolves on observable completion or rejects with the handled error
Creates a new Observable, with this Observable as the source, and the passed operator defined as the new observable's operator.
the operator defining the operation to take on the observable
a new observable with the Operator applied
Registers handlers for handling emitted values, error and completions from the observable, and executes the observable's subscriber function, which will take action to set up the underlying data stream
(optional) either an observer defining all functions to be called, or the first of three possible handlers, which is the handler for each value emitted from the observable.
(optional) a handler for a terminal event resulting from an error. If no error handler is provided, the error will be thrown as unhandled
(optional) a handler for a terminal event resulting from successful completion.
a subscription reference to the registered handlers
Creates an Observable that emits no items to the Observer.
An Observable that never emits anything.

This static operator is useful for creating a simple Observable that emits neither values nor errors nor the completion notification. It can be used for testing purposes or for composing with other Observables. Please not that by never emitting a complete notification, this Observable keeps the subscription from being disposed automatically. Subscriptions need to be manually disposed.
A "never" Observable: never emits anything.
We need this JSDoc comment for affecting ESDoc.
An interop point defined by the es7-observable spec https://github.com/zenparsing/es-observable
this instance of the observable
a handler for each value emitted by the observable
a promise that either resolves on observable completion or rejects with the handled error
Creates a new Observable, with this Observable as the source, and the passed operator defined as the new observable's operator.
the operator defining the operation to take on the observable
a new observable with the Operator applied
Registers handlers for handling emitted values, error and completions from the observable, and executes the observable's subscriber function, which will take action to set up the underlying data stream
(optional) either an observer defining all functions to be called, or the first of three possible handlers, which is the handler for each value emitted from the observable.
(optional) a handler for a terminal event resulting from an error. If no error handler is provided, the error will be thrown as unhandled
(optional) a handler for a terminal event resulting from successful completion.
a subscription reference to the registered handlers
We need this JSDoc comment for affecting ESDoc.
An interop point defined by the es7-observable spec https://github.com/zenparsing/es-observable
this instance of the observable
a handler for each value emitted by the observable
a promise that either resolves on observable completion or rejects with the handled error
Creates a new Observable, with this Observable as the source, and the passed operator defined as the new observable's operator.
the operator defining the operation to take on the observable
a new observable with the Operator applied
Registers handlers for handling emitted values, error and completions from the observable, and executes the observable's subscriber function, which will take action to set up the underlying data stream
(optional) either an observer defining all functions to be called, or the first of three possible handlers, which is the handler for each value emitted from the observable.
(optional) a handler for a terminal event resulting from an error. If no error handler is provided, the error will be thrown as unhandled
(optional) a handler for a terminal event resulting from successful completion.
a subscription reference to the registered handlers
Creates an Observable that emits a sequence of numbers within a specified range.
Emits a sequence of numbers in a range.

range operator emits a range of sequential integers, in order, where you
select the start of the range and its length. By default, uses no
Scheduler and just delivers the notifications synchronously, but may use
an optional Scheduler to regulate those deliveries.
An Observable of numbers that emits a finite range of sequential integers.
We need this JSDoc comment for affecting ESDoc.
An interop point defined by the es7-observable spec https://github.com/zenparsing/es-observable
this instance of the observable
a handler for each value emitted by the observable
a promise that either resolves on observable completion or rejects with the handled error
Creates a new Observable, with this Observable as the source, and the passed operator defined as the new observable's operator.
the operator defining the operation to take on the observable
a new observable with the Operator applied
Registers handlers for handling emitted values, error and completions from the observable, and executes the observable's subscriber function, which will take action to set up the underlying data stream
(optional) either an observer defining all functions to be called, or the first of three possible handlers, which is the handler for each value emitted from the observable.
(optional) a handler for a terminal event resulting from an error. If no error handler is provided, the error will be thrown as unhandled
(optional) a handler for a terminal event resulting from successful completion.
a subscription reference to the registered handlers
We need this JSDoc comment for affecting ESDoc.
An interop point defined by the es7-observable spec https://github.com/zenparsing/es-observable
this instance of the observable
a handler for each value emitted by the observable
a promise that either resolves on observable completion or rejects with the handled error
Creates a new Observable, with this Observable as the source, and the passed operator defined as the new observable's operator.
the operator defining the operation to take on the observable
a new observable with the Operator applied
Registers handlers for handling emitted values, error and completions from the observable, and executes the observable's subscriber function, which will take action to set up the underlying data stream
(optional) either an observer defining all functions to be called, or the first of three possible handlers, which is the handler for each value emitted from the observable.
(optional) a handler for a terminal event resulting from an error. If no error handler is provided, the error will be thrown as unhandled
(optional) a handler for a terminal event resulting from successful completion.
a subscription reference to the registered handlers
We need this JSDoc comment for affecting ESDoc.
An interop point defined by the es7-observable spec https://github.com/zenparsing/es-observable
this instance of the observable
a handler for each value emitted by the observable
a promise that either resolves on observable completion or rejects with the handled error
Creates a new Observable, with this Observable as the source, and the passed operator defined as the new observable's operator.
the operator defining the operation to take on the observable
a new observable with the Operator applied
Registers handlers for handling emitted values, error and completions from the observable, and executes the observable's subscriber function, which will take action to set up the underlying data stream
(optional) either an observer defining all functions to be called, or the first of three possible handlers, which is the handler for each value emitted from the observable.
(optional) a handler for a terminal event resulting from an error. If no error handler is provided, the error will be thrown as unhandled
(optional) a handler for a terminal event resulting from successful completion.
a subscription reference to the registered handlers
Creates an Observable that starts emitting after an initialDelay and
emits ever increasing numbers after each period of time thereafter.
Its like interval, but you can specify when should the emissions start.

timer returns an Observable that emits an infinite sequence of ascending
integers, with a constant interval of time, period of your choosing
between those emissions. The first emission happens after the specified
initialDelay. The initial delay may be a {@link Date}. By default, this
operator uses the async Scheduler to provide a notion of time, but you
may pass any Scheduler to it. If period is not specified, the output
Observable emits only one value, 0. Otherwise, it emits an infinite
sequence.
The initial delay time to wait before
emitting the first value of 0.
An Observable that emits a 0 after the
initialDelay and ever increasing numbers after each period of time
thereafter.
We need this JSDoc comment for affecting ESDoc.
An interop point defined by the es7-observable spec https://github.com/zenparsing/es-observable
this instance of the observable
a handler for each value emitted by the observable
a promise that either resolves on observable completion or rejects with the handled error
Creates a new Observable, with this Observable as the source, and the passed operator defined as the new observable's operator.
the operator defining the operation to take on the observable
a new observable with the Operator applied
Registers handlers for handling emitted values, error and completions from the observable, and executes the observable's subscriber function, which will take action to set up the underlying data stream
(optional) either an observer defining all functions to be called, or the first of three possible handlers, which is the handler for each value emitted from the observable.
(optional) a handler for a terminal event resulting from an error. If no error handler is provided, the error will be thrown as unhandled
(optional) a handler for a terminal event resulting from successful completion.
a subscription reference to the registered handlers
A flag to indicate whether this Subscription has already been unsubscribed.
Adds a tear down to be called during the unsubscribe() of this Subscription.
If the tear down being added is a subscription that is already
unsubscribed, is the same reference add is being called on, or is
Subscription.EMPTY, it will not be added.
If this subscription is already in an isUnsubscribed state, the passed
tear down logic will be executed immediately.
The additional logic to execute on teardown.
Returns the Subscription used or created to be
added to the inner subscriptions list. This Subscription can be used with
remove() to remove the passed teardown logic from the inner subscriptions
list.
The Observer callback to receive a valueless notification of type
complete from the Observable. Notifies the Observer that the Observable
has finished sending push-based notifications.
The Observer callback to receive notifications of type next from
the Observable, with a value. The Observable may call this method 0 or more
times.
Removes a Subscription from the internal list of subscriptions that will unsubscribe during the unsubscribe process of this Subscription.
The subscription to remove.
A static factory for a Subscriber, given a (potentially partial) definition of an Observer.
A Subscriber wrapping the (partially defined) Observer represented by the given arguments.
A normalized AJAX error.
We need this JSDoc comment for affecting ESDoc.
An interop point defined by the es7-observable spec https://github.com/zenparsing/es-observable
this instance of the observable
a handler for each value emitted by the observable
a promise that either resolves on observable completion or rejects with the handled error
Creates a new Observable, with this Observable as the source, and the passed operator defined as the new observable's operator.
the operator defining the operation to take on the observable
a new observable with the Operator applied
Registers handlers for handling emitted values, error and completions from the observable, and executes the observable's subscriber function, which will take action to set up the underlying data stream
(optional) either an observer defining all functions to be called, or the first of three possible handlers, which is the handler for each value emitted from the observable.
(optional) a handler for a terminal event resulting from an error. If no error handler is provided, the error will be thrown as unhandled
(optional) a handler for a terminal event resulting from successful completion.
a subscription reference to the registered handlers
Creates an observable for an Ajax request with either a request object with url, headers, etc or a string for a URL.
An observable sequence containing the XMLHttpRequest.
A normalized AJAX response.
We need this JSDoc comment for affecting ESDoc.
A flag to indicate whether this Subscription has already been unsubscribed.
Adds a tear down to be called during the unsubscribe() of this Subscription.
If the tear down being added is a subscription that is already
unsubscribed, is the same reference add is being called on, or is
Subscription.EMPTY, it will not be added.
If this subscription is already in an isUnsubscribed state, the passed
tear down logic will be executed immediately.
The additional logic to execute on teardown.
Returns the Subscription used or created to be
added to the inner subscriptions list. This Subscription can be used with
remove() to remove the passed teardown logic from the inner subscriptions
list.
The Observer callback to receive a valueless notification of type
complete from the Observable. Notifies the Observer that the Observable
has finished sending push-based notifications.
Removes a Subscription from the internal list of subscriptions that will unsubscribe during the unsubscribe process of this Subscription.
The subscription to remove.
A static factory for a Subscriber, given a (potentially partial) definition of an Observer.
A Subscriber wrapping the (partially defined) Observer represented by the given arguments.
We need this JSDoc comment for affecting ESDoc.
a handler for each value emitted by the observable
a promise that either resolves on observable completion or rejects with the handled error
Registers handlers for handling emitted values, error and completions from the observable, and executes the observable's subscriber function, which will take action to set up the underlying data stream
(optional) either an observer defining all functions to be called, or the first of three possible handlers, which is the handler for each value emitted from the observable.
(optional) a handler for a terminal event resulting from an error. If no error handler is provided, the error will be thrown as unhandled
(optional) a handler for a terminal event resulting from successful completion.
a subscription reference to the registered handlers
We need this JSDoc comment for affecting ESDoc.
A flag to indicate whether this Subscription has already been unsubscribed.
Adds a tear down to be called during the unsubscribe() of this Subscription.
If the tear down being added is a subscription that is already
unsubscribed, is the same reference add is being called on, or is
Subscription.EMPTY, it will not be added.
If this subscription is already in an isUnsubscribed state, the passed
tear down logic will be executed immediately.
The additional logic to execute on teardown.
Returns the Subscription used or created to be
added to the inner subscriptions list. This Subscription can be used with
remove() to remove the passed teardown logic from the inner subscriptions
list.
The Observer callback to receive a valueless notification of type
complete from the Observable. Notifies the Observer that the Observable
has finished sending push-based notifications.
The Observer callback to receive notifications of type next from
the Observable, with a value. The Observable may call this method 0 or more
times.
Removes a Subscription from the internal list of subscriptions that will unsubscribe during the unsubscribe process of this Subscription.
The subscription to remove.
A static factory for a Subscriber, given a (potentially partial) definition of an Observer.
A Subscriber wrapping the (partially defined) Observer represented by the given arguments.
We need this JSDoc comment for affecting ESDoc.
A flag to indicate whether this Subscription has already been unsubscribed.
Adds a tear down to be called during the unsubscribe() of this Subscription.
If the tear down being added is a subscription that is already
unsubscribed, is the same reference add is being called on, or is
Subscription.EMPTY, it will not be added.
If this subscription is already in an isUnsubscribed state, the passed
tear down logic will be executed immediately.
The additional logic to execute on teardown.
Returns the Subscription used or created to be
added to the inner subscriptions list. This Subscription can be used with
remove() to remove the passed teardown logic from the inner subscriptions
list.
The Observer callback to receive a valueless notification of type
complete from the Observable. Notifies the Observer that the Observable
has finished sending push-based notifications.
The Observer callback to receive notifications of type next from
the Observable, with a value. The Observable may call this method 0 or more
times.
Removes a Subscription from the internal list of subscriptions that will unsubscribe during the unsubscribe process of this Subscription.
The subscription to remove.
A static factory for a Subscriber, given a (potentially partial) definition of an Observer.
A Subscriber wrapping the (partially defined) Observer represented by the given arguments.
We need this JSDoc comment for affecting ESDoc.
A flag to indicate whether this Subscription has already been unsubscribed.
Adds a tear down to be called during the unsubscribe() of this Subscription.
If the tear down being added is a subscription that is already
unsubscribed, is the same reference add is being called on, or is
Subscription.EMPTY, it will not be added.
If this subscription is already in an isUnsubscribed state, the passed
tear down logic will be executed immediately.
The additional logic to execute on teardown.
Returns the Subscription used or created to be
added to the inner subscriptions list. This Subscription can be used with
remove() to remove the passed teardown logic from the inner subscriptions
list.
The Observer callback to receive a valueless notification of type
complete from the Observable. Notifies the Observer that the Observable
has finished sending push-based notifications.
The Observer callback to receive notifications of type next from
the Observable, with a value. The Observable may call this method 0 or more
times.
Removes a Subscription from the internal list of subscriptions that will unsubscribe during the unsubscribe process of this Subscription.
The subscription to remove.
A static factory for a Subscriber, given a (potentially partial) definition of an Observer.
A Subscriber wrapping the (partially defined) Observer represented by the given arguments.
Buffers the source Observable values until closingNotifier emits.
Collects values from the past as an array, and emits that array only when another Observable emits.

Buffers the incoming Observable values until the given closingNotifier
Observable emits a value, at which point it emits the buffer on the output
Observable and starts a new buffer internally, awaiting the next time
closingNotifier emits.
An Observable that signals the buffer to be emitted on the output Observable.
An Observable of buffers, which are arrays of values.
We need this JSDoc comment for affecting ESDoc.
A flag to indicate whether this Subscription has already been unsubscribed.
Adds a tear down to be called during the unsubscribe() of this Subscription.
If the tear down being added is a subscription that is already
unsubscribed, is the same reference add is being called on, or is
Subscription.EMPTY, it will not be added.
If this subscription is already in an isUnsubscribed state, the passed
tear down logic will be executed immediately.
The additional logic to execute on teardown.
Returns the Subscription used or created to be
added to the inner subscriptions list. This Subscription can be used with
remove() to remove the passed teardown logic from the inner subscriptions
list.
The Observer callback to receive a valueless notification of type
complete from the Observable. Notifies the Observer that the Observable
has finished sending push-based notifications.
The Observer callback to receive notifications of type next from
the Observable, with a value. The Observable may call this method 0 or more
times.
Removes a Subscription from the internal list of subscriptions that will unsubscribe during the unsubscribe process of this Subscription.
The subscription to remove.
A static factory for a Subscriber, given a (potentially partial) definition of an Observer.
A Subscriber wrapping the (partially defined) Observer represented by the given arguments.
Buffers the source Observable values until the size hits the maximum
bufferSize given.
Collects values from the past as an array, and emits
that array only when its size reaches bufferSize.

Buffers a number of values from the source Observable by bufferSize then
emits the buffer and clears it, and starts a new buffer each
startBufferEvery values. If startBufferEvery is not provided or is
null, then new buffers are started immediately at the start of the source
and when each buffer closes and is emitted.
The maximum size of the buffer emitted.
An Observable of arrays of buffered values.
We need this JSDoc comment for affecting ESDoc.
A flag to indicate whether this Subscription has already been unsubscribed.
Adds a tear down to be called during the unsubscribe() of this Subscription.
If the tear down being added is a subscription that is already
unsubscribed, is the same reference add is being called on, or is
Subscription.EMPTY, it will not be added.
If this subscription is already in an isUnsubscribed state, the passed
tear down logic will be executed immediately.
The additional logic to execute on teardown.
Returns the Subscription used or created to be
added to the inner subscriptions list. This Subscription can be used with
remove() to remove the passed teardown logic from the inner subscriptions
list.
The Observer callback to receive a valueless notification of type
complete from the Observable. Notifies the Observer that the Observable
has finished sending push-based notifications.
The Observer callback to receive notifications of type next from
the Observable, with a value. The Observable may call this method 0 or more
times.
Removes a Subscription from the internal list of subscriptions that will unsubscribe during the unsubscribe process of this Subscription.
The subscription to remove.
A static factory for a Subscriber, given a (potentially partial) definition of an Observer.
A Subscriber wrapping the (partially defined) Observer represented by the given arguments.
Buffers the source Observable values for a specific time period.
Collects values from the past as an array, and emits those arrays periodically in time.

Buffers values from the source for a specific time duration bufferTimeSpan.
Unless the optional argument bufferCreationInterval is given, it emits and
resets the buffer every bufferTimeSpan milliseconds. If
bufferCreationInterval is given, this operator opens the buffer every
bufferCreationInterval milliseconds and closes (emits and resets) the
buffer every bufferTimeSpan milliseconds.
The amount of time to fill each buffer array.
An observable of arrays of buffered values.
We need this JSDoc comment for affecting ESDoc.
A flag to indicate whether this Subscription has already been unsubscribed.
Adds a tear down to be called during the unsubscribe() of this Subscription.
If the tear down being added is a subscription that is already
unsubscribed, is the same reference add is being called on, or is
Subscription.EMPTY, it will not be added.
If this subscription is already in an isUnsubscribed state, the passed
tear down logic will be executed immediately.
The additional logic to execute on teardown.
Returns the Subscription used or created to be
added to the inner subscriptions list. This Subscription can be used with
remove() to remove the passed teardown logic from the inner subscriptions
list.
The Observer callback to receive a valueless notification of type
complete from the Observable. Notifies the Observer that the Observable
has finished sending push-based notifications.
The Observer callback to receive notifications of type next from
the Observable, with a value. The Observable may call this method 0 or more
times.
Removes a Subscription from the internal list of subscriptions that will unsubscribe during the unsubscribe process of this Subscription.
The subscription to remove.
A static factory for a Subscriber, given a (potentially partial) definition of an Observer.
A Subscriber wrapping the (partially defined) Observer represented by the given arguments.
Buffers the source Observable values starting from an emission from
openings and ending when the output of closingSelector emits.
Collects values from the past as an array. Starts
collecting only when opening emits, and calls the closingSelector
function to get an Observable that tells when to close the buffer.

Buffers values from the source by opening the buffer via signals from an
Observable provided to openings, and closing and sending the buffers when
a Subscribable or Promise returned by the closingSelector function emits.
A Subscribable or Promise of notifications to start new buffers.
A function that takes
the value emitted by the openings observable and returns a Subscribable or Promise,
which, when it emits, signals that the associated buffer should be emitted
and cleared.
An observable of arrays of buffered values.
We need this JSDoc comment for affecting ESDoc.
A flag to indicate whether this Subscription has already been unsubscribed.
Adds a tear down to be called during the unsubscribe() of this Subscription.
If the tear down being added is a subscription that is already
unsubscribed, is the same reference add is being called on, or is
Subscription.EMPTY, it will not be added.
If this subscription is already in an isUnsubscribed state, the passed
tear down logic will be executed immediately.
The additional logic to execute on teardown.
Returns the Subscription used or created to be
added to the inner subscriptions list. This Subscription can be used with
remove() to remove the passed teardown logic from the inner subscriptions
list.
The Observer callback to receive a valueless notification of type
complete from the Observable. Notifies the Observer that the Observable
has finished sending push-based notifications.
The Observer callback to receive notifications of type next from
the Observable, with a value. The Observable may call this method 0 or more
times.
Removes a Subscription from the internal list of subscriptions that will unsubscribe during the unsubscribe process of this Subscription.
The subscription to remove.
A static factory for a Subscriber, given a (potentially partial) definition of an Observer.
A Subscriber wrapping the (partially defined) Observer represented by the given arguments.
Buffers the source Observable values, using a factory function of closing Observables to determine when to close, emit, and reset the buffer.
Collects values from the past as an array. When it starts collecting values, it calls a function that returns an Observable that tells when to close the buffer and restart collecting.

Opens a buffer immediately, then closes the buffer when the observable
returned by calling closingSelector function emits a value. When it closes
the buffer, it immediately opens a new buffer and repeats the process.
A function that takes no arguments and returns an Observable that signals buffer closure.
An observable of arrays of buffered values.
We need this JSDoc comment for affecting ESDoc.
A flag to indicate whether this Subscription has already been unsubscribed.
Adds a tear down to be called during the unsubscribe() of this Subscription.
If the tear down being added is a subscription that is already
unsubscribed, is the same reference add is being called on, or is
Subscription.EMPTY, it will not be added.
If this subscription is already in an isUnsubscribed state, the passed
tear down logic will be executed immediately.
The additional logic to execute on teardown.
Returns the Subscription used or created to be
added to the inner subscriptions list. This Subscription can be used with
remove() to remove the passed teardown logic from the inner subscriptions
list.
The Observer callback to receive a valueless notification of type
complete from the Observable. Notifies the Observer that the Observable
has finished sending push-based notifications.
The Observer callback to receive notifications of type next from
the Observable, with a value. The Observable may call this method 0 or more
times.
Removes a Subscription from the internal list of subscriptions that will unsubscribe during the unsubscribe process of this Subscription.
The subscription to remove.
A static factory for a Subscriber, given a (potentially partial) definition of an Observer.
A Subscriber wrapping the (partially defined) Observer represented by the given arguments.
Catches errors on the observable to be handled by returning a new observable or throwing an error.
a function that takes as arguments err, which is the error, and caught, which
is the source observable, in case you'd like to "retry" that observable by returning it again. Whatever observable
is returned by the selector will be used to continue the observable chain.
an observable that originates from either the source or the observable returned by the
catch selector function.
Converts a higher-order Observable into a first-order Observable by waiting for the outer Observable to complete, then applying combineLatest.
Flattens an Observable-of-Observables by applying combineLatest when the Observable-of-Observables completes.

Takes an Observable of Observables, and collects all Observables from it. Once the outer Observable completes, it subscribes to all collected Observables and combines their values using the combineLatest strategy, such that:
project function is provided, it is called with each recent value
from each inner Observable in whatever order they arrived, and the result
of the project function is what is emitted by the output Observable.project function, an array of all of the most recent
values is emitted by the output Observable.An Observable of projected results or arrays of recent values.
We need this JSDoc comment for affecting ESDoc.
A flag to indicate whether this Subscription has already been unsubscribed.
Adds a tear down to be called during the unsubscribe() of this Subscription.
If the tear down being added is a subscription that is already
unsubscribed, is the same reference add is being called on, or is
Subscription.EMPTY, it will not be added.
If this subscription is already in an isUnsubscribed state, the passed
tear down logic will be executed immediately.
The additional logic to execute on teardown.
Returns the Subscription used or created to be
added to the inner subscriptions list. This Subscription can be used with
remove() to remove the passed teardown logic from the inner subscriptions
list.
The Observer callback to receive a valueless notification of type
complete from the Observable. Notifies the Observer that the Observable
has finished sending push-based notifications.
The Observer callback to receive notifications of type next from
the Observable, with a value. The Observable may call this method 0 or more
times.
Removes a Subscription from the internal list of subscriptions that will unsubscribe during the unsubscribe process of this Subscription.
The subscription to remove.
A static factory for a Subscriber, given a (potentially partial) definition of an Observer.
A Subscriber wrapping the (partially defined) Observer represented by the given arguments.
Combines multiple Observables to create an Observable whose values are calculated from the latest values of each of its input Observables.
Whenever any input Observable emits a value, it computes a formula using the latest values from all the inputs, then emits the output of that formula.

combineLatest combines the values from this Observable with values from
Observables passed as arguments. This is done by subscribing to each
Observable, in order, and collecting an array of each of the most recent
values any time any of the input Observables emits, then either taking that
array and passing it as arguments to an optional project function and
emitting the return value of that, or just emitting the array of recent
values directly if there is no project function.
An Observable of projected values from the most recent values from each input Observable, or an array of the most recent values from each input Observable.
Combines the values from observables passed as arguments. This is done by subscribing
to each observable, in order, and collecting an array of each of the most recent values any time any of the observables
emits, then either taking that array and passing it as arguments to an option project function and emitting the return
value of that, or just emitting the array of recent values directly if there is no project function.
an observable of other projected values from the most recent values from each observable, or an array of each of the most recent values from each observable.
Combines the values from observables passed as arguments. This is done by subscribing
to each observable, in order, and collecting an array of each of the most recent values any time any of the observables
emits, then either taking that array and passing it as arguments to an option project function and emitting the return
value of that, or just emitting the array of recent values directly if there is no project function.
an observable of other projected values from the most recent values from each observable, or an array of each of the most recent values from each observable.
Combines the values from observables passed as arguments. This is done by subscribing
to each observable, in order, and collecting an array of each of the most recent values any time any of the observables
emits, then either taking that array and passing it as arguments to an option project function and emitting the return
value of that, or just emitting the array of recent values directly if there is no project function.
an observable of other projected values from the most recent values from each observable, or an array of each of the most recent values from each observable.
Combines the values from observables passed as arguments. This is done by subscribing
to each observable, in order, and collecting an array of each of the most recent values any time any of the observables
emits, then either taking that array and passing it as arguments to an option project function and emitting the return
value of that, or just emitting the array of recent values directly if there is no project function.
an observable of other projected values from the most recent values from each observable, or an array of each of the most recent values from each observable.
Combines the values from observables passed as arguments. This is done by subscribing
to each observable, in order, and collecting an array of each of the most recent values any time any of the observables
emits, then either taking that array and passing it as arguments to an option project function and emitting the return
value of that, or just emitting the array of recent values directly if there is no project function.
an observable of other projected values from the most recent values from each observable, or an array of each of the most recent values from each observable.
Combines the values from observables passed as arguments. This is done by subscribing
to each observable, in order, and collecting an array of each of the most recent values any time any of the observables
emits, then either taking that array and passing it as arguments to an option project function and emitting the return
value of that, or just emitting the array of recent values directly if there is no project function.
an observable of other projected values from the most recent values from each observable, or an array of each of the most recent values from each observable.
Combines the values from observables passed as arguments. This is done by subscribing
to each observable, in order, and collecting an array of each of the most recent values any time any of the observables
emits, then either taking that array and passing it as arguments to an option project function and emitting the return
value of that, or just emitting the array of recent values directly if there is no project function.
an observable of other projected values from the most recent values from each observable, or an array of each of the most recent values from each observable.
Combines the values from observables passed as arguments. This is done by subscribing
to each observable, in order, and collecting an array of each of the most recent values any time any of the observables
emits, then either taking that array and passing it as arguments to an option project function and emitting the return
value of that, or just emitting the array of recent values directly if there is no project function.
an observable of other projected values from the most recent values from each observable, or an array of each of the most recent values from each observable.
Combines the values from observables passed as arguments. This is done by subscribing
to each observable, in order, and collecting an array of each of the most recent values any time any of the observables
emits, then either taking that array and passing it as arguments to an option project function and emitting the return
value of that, or just emitting the array of recent values directly if there is no project function.
an observable of other projected values from the most recent values from each observable, or an array of each of the most recent values from each observable.
Combines the values from observables passed as arguments. This is done by subscribing
to each observable, in order, and collecting an array of each of the most recent values any time any of the observables
emits, then either taking that array and passing it as arguments to an option project function and emitting the return
value of that, or just emitting the array of recent values directly if there is no project function.
an observable of other projected values from the most recent values from each observable, or an array of each of the most recent values from each observable.
Combines the values from observables passed as arguments. This is done by subscribing
to each observable, in order, and collecting an array of each of the most recent values any time any of the observables
emits, then either taking that array and passing it as arguments to an option project function and emitting the return
value of that, or just emitting the array of recent values directly if there is no project function.
an observable of other projected values from the most recent values from each observable, or an array of each of the most recent values from each observable.
Combines the values from observables passed as arguments. This is done by subscribing
to each observable, in order, and collecting an array of each of the most recent values any time any of the observables
emits, then either taking that array and passing it as arguments to an option project function and emitting the return
value of that, or just emitting the array of recent values directly if there is no project function.
an observable of other projected values from the most recent values from each observable, or an array of each of the most recent values from each observable.
Combines the values from observables passed as arguments. This is done by subscribing
to each observable, in order, and collecting an array of each of the most recent values any time any of the observables
emits, then either taking that array and passing it as arguments to an option project function and emitting the return
value of that, or just emitting the array of recent values directly if there is no project function.
the observables to combine
an observable of other projected values from the most recent values from each observable, or an array of each of the most recent values from each observable.
Combines the values from observables passed as arguments. This is done by subscribing
to each observable, in order, and collecting an array of each of the most recent values any time any of the observables
emits, then either taking that array and passing it as arguments to an option project function and emitting the return
value of that, or just emitting the array of recent values directly if there is no project function.
an observable of other projected values from the most recent values from each observable, or an array of each of the most recent values from each observable.
Combines the values from observables passed as arguments. This is done by subscribing
to each observable, in order, and collecting an array of each of the most recent values any time any of the observables
emits, then either taking that array and passing it as arguments to an option project function and emitting the return
value of that, or just emitting the array of recent values directly if there is no project function.
an observable of other projected values from the most recent values from each observable, or an array of each of the most recent values from each observable.
Creates an output Observable which sequentially emits all values from every given input Observable after the current Observable.
Concatenates multiple Observables together by sequentially emitting their values, one Observable after the other.

Joins this Observable with multiple other Observables by subscribing to them one at a time, starting with the source, and merging their results into the output Observable. Will wait for each Observable to complete before moving on to the next.
All values of each passed Observable merged into a single Observable, in order, in serial fashion.
Creates an output Observable which sequentially emits all values from every given input Observable after the current Observable.
Concatenates multiple Observables together by sequentially emitting their values, one Observable after the other.

Joins multiple Observables together by subscribing to them one at a time and merging their results into the output Observable. Will wait for each Observable to complete before moving on to the next.
All values of each passed Observable merged into a single Observable, in order, in serial fashion.
Creates an output Observable which sequentially emits all values from every given input Observable after the current Observable.
Concatenates multiple Observables together by sequentially emitting their values, one Observable after the other.

Joins multiple Observables together by subscribing to them one at a time and merging their results into the output Observable. Will wait for each Observable to complete before moving on to the next.
All values of each passed Observable merged into a single Observable, in order, in serial fashion.
Creates an output Observable which sequentially emits all values from every given input Observable after the current Observable.
Concatenates multiple Observables together by sequentially emitting their values, one Observable after the other.

Joins multiple Observables together by subscribing to them one at a time and merging their results into the output Observable. Will wait for each Observable to complete before moving on to the next.
All values of each passed Observable merged into a single Observable, in order, in serial fashion.
Creates an output Observable which sequentially emits all values from every given input Observable after the current Observable.
Concatenates multiple Observables together by sequentially emitting their values, one Observable after the other.

Joins multiple Observables together by subscribing to them one at a time and merging their results into the output Observable. Will wait for each Observable to complete before moving on to the next.
All values of each passed Observable merged into a single Observable, in order, in serial fashion.
Creates an output Observable which sequentially emits all values from every given input Observable after the current Observable.
Concatenates multiple Observables together by sequentially emitting their values, one Observable after the other.

Joins multiple Observables together by subscribing to them one at a time and merging their results into the output Observable. Will wait for each Observable to complete before moving on to the next.
All values of each passed Observable merged into a single Observable, in order, in serial fashion.
Creates an output Observable which sequentially emits all values from every given input Observable after the current Observable.
Concatenates multiple Observables together by sequentially emitting their values, one Observable after the other.

Joins multiple Observables together by subscribing to them one at a time and merging their results into the output Observable. Will wait for each Observable to complete before moving on to the next.
All values of each passed Observable merged into a single Observable, in order, in serial fashion.
Creates an output Observable which sequentially emits all values from every given input Observable after the current Observable.
Concatenates multiple Observables together by sequentially emitting their values, one Observable after the other.

Joins multiple Observables together by subscribing to them one at a time and merging their results into the output Observable. Will wait for each Observable to complete before moving on to the next.
All values of each passed Observable merged into a single Observable, in order, in serial fashion.
Creates an output Observable which sequentially emits all values from every given input Observable after the current Observable.
Concatenates multiple Observables together by sequentially emitting their values, one Observable after the other.

Joins multiple Observables together by subscribing to them one at a time and merging their results into the output Observable. Will wait for each Observable to complete before moving on to the next.
All values of each passed Observable merged into a single Observable, in order, in serial fashion.
Converts a higher-order Observable into a first-order Observable by concatenating the inner Observables in order.
Flattens an Observable-of-Observables by putting one inner Observable after the other.

Joins every Observable emitted by the source (a higher-order Observable), in a serial fashion. It subscribes to each inner Observable only after the previous inner Observable has completed, and merges all of their values into the returned observable.
Warning: If the source Observable emits Observables quickly and endlessly, and the inner Observables it emits generally complete slower than the source emits, you can run into memory issues as the incoming Observables collect in an unbounded buffer.
Note: concatAll is equivalent to mergeAll with concurrency parameter set
to 1.
An Observable emitting values from all the inner Observables concatenated.
Projects each source value to an Observable which is merged in the output Observable, in a serialized fashion waiting for each one to complete before merging the next.
Maps each value to an Observable, then flattens all of these inner Observables using concatAll.

Returns an Observable that emits items based on applying a function that you supply to each item emitted by the source Observable, where that function returns an (so-called "inner") Observable. Each new inner Observable is concatenated with the previous inner Observable.
Warning: if source values arrive endlessly and faster than their corresponding inner Observables can complete, it will result in memory issues as inner Observables amass in an unbounded buffer waiting for their turn to be subscribed to.
Note: concatMap is equivalent to mergeMap with concurrency parameter set
to 1.
A function that, when applied to an item emitted by the source Observable, returns an Observable.
an observable of values merged from the projected
Observables as they were subscribed to, one at a time. Optionally, these
values may have been projected from a passed projectResult argument.
Projects each source value to the same Observable which is merged multiple times in a serialized fashion on the output Observable.
It's like concatMap, but maps each value always to the same inner Observable.

Maps each source value to the given Observable innerObservable regardless
of the source value, and then flattens those resulting Observables into one
single Observable, which is the output Observable. Each new innerObservable
instance emitted on the output Observable is concatenated with the previous
innerObservable instance.
Warning: if source values arrive endlessly and faster than their corresponding inner Observables can complete, it will result in memory issues as inner Observables amass in an unbounded buffer waiting for their turn to be subscribed to.
Note: concatMapTo is equivalent to mergeMapTo with concurrency parameter
set to 1.
An Observable to replace each value from the source Observable.
An observable of values merged together by joining the passed observable with itself, one after the other, for each value emitted from the source.
We need this JSDoc comment for affecting ESDoc.
A flag to indicate whether this Subscription has already been unsubscribed.
Adds a tear down to be called during the unsubscribe() of this Subscription.
If the tear down being added is a subscription that is already
unsubscribed, is the same reference add is being called on, or is
Subscription.EMPTY, it will not be added.
If this subscription is already in an isUnsubscribed state, the passed
tear down logic will be executed immediately.
The additional logic to execute on teardown.
Returns the Subscription used or created to be
added to the inner subscriptions list. This Subscription can be used with
remove() to remove the passed teardown logic from the inner subscriptions
list.
The Observer callback to receive a valueless notification of type
complete from the Observable. Notifies the Observer that the Observable
has finished sending push-based notifications.
The Observer callback to receive notifications of type next from
the Observable, with a value. The Observable may call this method 0 or more
times.
Removes a Subscription from the internal list of subscriptions that will unsubscribe during the unsubscribe process of this Subscription.
The subscription to remove.
A static factory for a Subscriber, given a (potentially partial) definition of an Observer.
A Subscriber wrapping the (partially defined) Observer represented by the given arguments.
Counts the number of emissions on the source and emits that number when the source completes.
Tells how many values were emitted, when the source completes.

count transforms an Observable that emits values into an Observable that
emits a single value that represents the number of values emitted by the
source Observable. If the source Observable terminates with an error, count
will pass this error notification along without emitting an value first. If
the source Observable does not terminate at all, count will neither emit
a value nor terminate. This operator takes an optional predicate function
as argument, in which case the output emission will represent the number of
source values that matched true with the predicate.
An Observable of one number that represents the count as described above.
We need this JSDoc comment for affecting ESDoc.
A flag to indicate whether this Subscription has already been unsubscribed.
Adds a tear down to be called during the unsubscribe() of this Subscription.
If the tear down being added is a subscription that is already
unsubscribed, is the same reference add is being called on, or is
Subscription.EMPTY, it will not be added.
If this subscription is already in an isUnsubscribed state, the passed
tear down logic will be executed immediately.
The additional logic to execute on teardown.
Returns the Subscription used or created to be
added to the inner subscriptions list. This Subscription can be used with
remove() to remove the passed teardown logic from the inner subscriptions
list.
The Observer callback to receive a valueless notification of type
complete from the Observable. Notifies the Observer that the Observable
has finished sending push-based notifications.
The Observer callback to receive notifications of type next from
the Observable, with a value. The Observable may call this method 0 or more
times.
Removes a Subscription from the internal list of subscriptions that will unsubscribe during the unsubscribe process of this Subscription.
The subscription to remove.
A static factory for a Subscriber, given a (potentially partial) definition of an Observer.
A Subscriber wrapping the (partially defined) Observer represented by the given arguments.
Returns the source Observable delayed by the computed debounce duration,
with the duration lengthened if a new source item arrives before the delay
duration ends.
In practice, for each item emitted on the source, this operator holds the
latest item, waits for a silence as long as the durationSelector specifies,
and only then emits the latest source item on the result Observable.
function for computing the timeout duration for each item.
an Observable the same as source Observable, but drops items.
We need this JSDoc comment for affecting ESDoc.
A flag to indicate whether this Subscription has already been unsubscribed.
Adds a tear down to be called during the unsubscribe() of this Subscription.
If the tear down being added is a subscription that is already
unsubscribed, is the same reference add is being called on, or is
Subscription.EMPTY, it will not be added.
If this subscription is already in an isUnsubscribed state, the passed
tear down logic will be executed immediately.
The additional logic to execute on teardown.
Returns the Subscription used or created to be
added to the inner subscriptions list. This Subscription can be used with
remove() to remove the passed teardown logic from the inner subscriptions
list.
The Observer callback to receive a valueless notification of type
complete from the Observable. Notifies the Observer that the Observable
has finished sending push-based notifications.
The Observer callback to receive notifications of type next from
the Observable, with a value. The Observable may call this method 0 or more
times.
Removes a Subscription from the internal list of subscriptions that will unsubscribe during the unsubscribe process of this Subscription.
The subscription to remove.
A static factory for a Subscriber, given a (potentially partial) definition of an Observer.
A Subscriber wrapping the (partially defined) Observer represented by the given arguments.
Returns the source Observable delayed by the computed debounce duration,
with the duration lengthened if a new source item arrives before the delay
duration ends.
In practice, for each item emitted on the source, this operator holds the
latest item, waits for a silence for the dueTime length, and only then
emits the latest source item on the result Observable.
Optionally takes a scheduler for manging timers.
the timeout value for the window of time required to not drop the item.
an Observable the same as source Observable, but drops items.
We need this JSDoc comment for affecting ESDoc.
A flag to indicate whether this Subscription has already been unsubscribed.
Adds a tear down to be called during the unsubscribe() of this Subscription.
If the tear down being added is a subscription that is already
unsubscribed, is the same reference add is being called on, or is
Subscription.EMPTY, it will not be added.
If this subscription is already in an isUnsubscribed state, the passed
tear down logic will be executed immediately.
The additional logic to execute on teardown.
Returns the Subscription used or created to be
added to the inner subscriptions list. This Subscription can be used with
remove() to remove the passed teardown logic from the inner subscriptions
list.
The Observer callback to receive a valueless notification of type
complete from the Observable. Notifies the Observer that the Observable
has finished sending push-based notifications.
The Observer callback to receive notifications of type next from
the Observable, with a value. The Observable may call this method 0 or more
times.
Removes a Subscription from the internal list of subscriptions that will unsubscribe during the unsubscribe process of this Subscription.
The subscription to remove.
A static factory for a Subscriber, given a (potentially partial) definition of an Observer.
A Subscriber wrapping the (partially defined) Observer represented by the given arguments.
Returns an Observable that emits the elements of the source or a specified default value if empty.
the default value used if source is empty; defaults to null.
an Observable of the items emitted by the where empty values are replaced by the specified default value or null.
We need this JSDoc comment for affecting ESDoc.
A flag to indicate whether this Subscription has already been unsubscribed.
Adds a tear down to be called during the unsubscribe() of this Subscription.
If the tear down being added is a subscription that is already
unsubscribed, is the same reference add is being called on, or is
Subscription.EMPTY, it will not be added.
If this subscription is already in an isUnsubscribed state, the passed
tear down logic will be executed immediately.
The additional logic to execute on teardown.
Returns the Subscription used or created to be
added to the inner subscriptions list. This Subscription can be used with
remove() to remove the passed teardown logic from the inner subscriptions
list.
The Observer callback to receive a valueless notification of type
complete from the Observable. Notifies the Observer that the Observable
has finished sending push-based notifications.
The Observer callback to receive notifications of type next from
the Observable, with a value. The Observable may call this method 0 or more
times.
Removes a Subscription from the internal list of subscriptions that will unsubscribe during the unsubscribe process of this Subscription.
The subscription to remove.
A static factory for a Subscriber, given a (potentially partial) definition of an Observer.
A Subscriber wrapping the (partially defined) Observer represented by the given arguments.
Delays the emission of items from the source Observable by a given timeout or until a given Date.
Time shifts each item by some specified amount of milliseconds.

If the delay argument is a Number, this operator time shifts the source Observable by that amount of time expressed in milliseconds. The relative time intervals between the values are preserved.
If the delay argument is a Date, this operator time shifts the start of the Observable execution until the given date occurs.
The delay duration in milliseconds (a number) or
a Date until which the emission of the source items is delayed.
An Observable that delays the emissions of the source Observable by the specified timeout or Date.
We need this JSDoc comment for affecting ESDoc.
A flag to indicate whether this Subscription has already been unsubscribed.
Adds a tear down to be called during the unsubscribe() of this Subscription.
If the tear down being added is a subscription that is already
unsubscribed, is the same reference add is being called on, or is
Subscription.EMPTY, it will not be added.
If this subscription is already in an isUnsubscribed state, the passed
tear down logic will be executed immediately.
The additional logic to execute on teardown.
Returns the Subscription used or created to be
added to the inner subscriptions list. This Subscription can be used with
remove() to remove the passed teardown logic from the inner subscriptions
list.
The Observer callback to receive a valueless notification of type
complete from the Observable. Notifies the Observer that the Observable
has finished sending push-based notifications.
The Observer callback to receive notifications of type next from
the Observable, with a value. The Observable may call this method 0 or more
times.
Removes a Subscription from the internal list of subscriptions that will unsubscribe during the unsubscribe process of this Subscription.
The subscription to remove.
A static factory for a Subscriber, given a (potentially partial) definition of an Observer.
A Subscriber wrapping the (partially defined) Observer represented by the given arguments.
We need this JSDoc comment for affecting ESDoc.
An interop point defined by the es7-observable spec https://github.com/zenparsing/es-observable
this instance of the observable
a handler for each value emitted by the observable
a promise that either resolves on observable completion or rejects with the handled error
Creates a new Observable, with this Observable as the source, and the passed operator defined as the new observable's operator.
the operator defining the operation to take on the observable
a new observable with the Operator applied
Registers handlers for handling emitted values, error and completions from the observable, and executes the observable's subscriber function, which will take action to set up the underlying data stream
(optional) either an observer defining all functions to be called, or the first of three possible handlers, which is the handler for each value emitted from the observable.
(optional) a handler for a terminal event resulting from an error. If no error handler is provided, the error will be thrown as unhandled
(optional) a handler for a terminal event resulting from successful completion.
a subscription reference to the registered handlers
Creates a new cold Observable by calling the Observable constructor
a new cold observable
We need this JSDoc comment for affecting ESDoc.
A flag to indicate whether this Subscription has already been unsubscribed.
Adds a tear down to be called during the unsubscribe() of this Subscription.
If the tear down being added is a subscription that is already
unsubscribed, is the same reference add is being called on, or is
Subscription.EMPTY, it will not be added.
If this subscription is already in an isUnsubscribed state, the passed
tear down logic will be executed immediately.
The additional logic to execute on teardown.
Returns the Subscription used or created to be
added to the inner subscriptions list. This Subscription can be used with
remove() to remove the passed teardown logic from the inner subscriptions
list.
The Observer callback to receive a valueless notification of type
complete from the Observable. Notifies the Observer that the Observable
has finished sending push-based notifications.
The Observer callback to receive notifications of type next from
the Observable, with a value. The Observable may call this method 0 or more
times.
Removes a Subscription from the internal list of subscriptions that will unsubscribe during the unsubscribe process of this Subscription.
The subscription to remove.
A static factory for a Subscriber, given a (potentially partial) definition of an Observer.
A Subscriber wrapping the (partially defined) Observer represented by the given arguments.
Returns an Observable that delays the emission of items from the source Observable by a subscription delay and a delay selector function for each element.
an Observable that delays the emissions of the source Observable by the specified timeout or Date.
We need this JSDoc comment for affecting ESDoc.
A flag to indicate whether this Subscription has already been unsubscribed.
Adds a tear down to be called during the unsubscribe() of this Subscription.
If the tear down being added is a subscription that is already
unsubscribed, is the same reference add is being called on, or is
Subscription.EMPTY, it will not be added.
If this subscription is already in an isUnsubscribed state, the passed
tear down logic will be executed immediately.
The additional logic to execute on teardown.
Returns the Subscription used or created to be
added to the inner subscriptions list. This Subscription can be used with
remove() to remove the passed teardown logic from the inner subscriptions
list.
The Observer callback to receive a valueless notification of type
complete from the Observable. Notifies the Observer that the Observable
has finished sending push-based notifications.
The Observer callback to receive notifications of type next from
the Observable, with a value. The Observable may call this method 0 or more
times.
Removes a Subscription from the internal list of subscriptions that will unsubscribe during the unsubscribe process of this Subscription.
The subscription to remove.
A static factory for a Subscriber, given a (potentially partial) definition of an Observer.
A Subscriber wrapping the (partially defined) Observer represented by the given arguments.
Returns an Observable that transforms Notification objects into the items or notifications they represent.
an Observable that emits items and notifications embedded in Notification objects emitted by the source Observable.
We need this JSDoc comment for affecting ESDoc.
A flag to indicate whether this Subscription has already been unsubscribed.
Adds a tear down to be called during the unsubscribe() of this Subscription.
If the tear down being added is a subscription that is already
unsubscribed, is the same reference add is being called on, or is
Subscription.EMPTY, it will not be added.
If this subscription is already in an isUnsubscribed state, the passed
tear down logic will be executed immediately.
The additional logic to execute on teardown.
Returns the Subscription used or created to be
added to the inner subscriptions list. This Subscription can be used with
remove() to remove the passed teardown logic from the inner subscriptions
list.
The Observer callback to receive a valueless notification of type
complete from the Observable. Notifies the Observer that the Observable
has finished sending push-based notifications.
The Observer callback to receive notifications of type next from
the Observable, with a value. The Observable may call this method 0 or more
times.
Removes a Subscription from the internal list of subscriptions that will unsubscribe during the unsubscribe process of this Subscription.
The subscription to remove.
A static factory for a Subscriber, given a (potentially partial) definition of an Observer.
A Subscriber wrapping the (partially defined) Observer represented by the given arguments.
Returns an Observable that emits all items emitted by the source Observable that are distinct by comparison from previous items. If a comparator function is provided, then it will be called for each item to test for whether or not that value should be emitted. If a comparator function is not provided, an equality check is used by default. As the internal HashSet of this operator grows larger and larger, care should be taken in the domain of inputs this operator may see. An optional parameter is also provided such that an Observable can be provided to queue the internal HashSet to flush the values it holds.
an Observable that emits items from the source Observable with distinct values.
Returns an Observable that emits all items emitted by the source Observable that are distinct by comparison from previous items, using a property accessed by using the key provided to check if the two items are distinct. If a comparator function is provided, then it will be called for each item to test for whether or not that value should be emitted. If a comparator function is not provided, an equality check is used by default. As the internal HashSet of this operator grows larger and larger, care should be taken in the domain of inputs this operator may see. An optional parameter is also provided such that an Observable can be provided to queue the internal HashSet to flush the values it holds.
string key for object property lookup on each item.
an Observable that emits items from the source Observable with distinct values.
We need this JSDoc comment for affecting ESDoc.
A flag to indicate whether this Subscription has already been unsubscribed.
Adds a tear down to be called during the unsubscribe() of this Subscription.
If the tear down being added is a subscription that is already
unsubscribed, is the same reference add is being called on, or is
Subscription.EMPTY, it will not be added.
If this subscription is already in an isUnsubscribed state, the passed
tear down logic will be executed immediately.
The additional logic to execute on teardown.
Returns the Subscription used or created to be
added to the inner subscriptions list. This Subscription can be used with
remove() to remove the passed teardown logic from the inner subscriptions
list.
The Observer callback to receive a valueless notification of type
complete from the Observable. Notifies the Observer that the Observable
has finished sending push-based notifications.
The Observer callback to receive notifications of type next from
the Observable, with a value. The Observable may call this method 0 or more
times.
Removes a Subscription from the internal list of subscriptions that will unsubscribe during the unsubscribe process of this Subscription.
The subscription to remove.
A static factory for a Subscriber, given a (potentially partial) definition of an Observer.
A Subscriber wrapping the (partially defined) Observer represented by the given arguments.
Returns an Observable that emits all items emitted by the source Observable that are distinct by comparison from the previous item. If a comparator function is provided, then it will be called for each item to test for whether or not that value should be emitted. If a comparator function is not provided, an equality check is used by default.
an Observable that emits items from the source Observable with distinct values.
Returns an Observable that emits all items emitted by the source Observable that are distinct by comparison from the previous item, using a property accessed by using the key provided to check if the two items are distinct. If a comparator function is provided, then it will be called for each item to test for whether or not that value should be emitted. If a comparator function is not provided, an equality check is used by default.
string key for object property lookup on each item.
an Observable that emits items from the source Observable with distinct values based on the key specified.
We need this JSDoc comment for affecting ESDoc.
A flag to indicate whether this Subscription has already been unsubscribed.
Adds a tear down to be called during the unsubscribe() of this Subscription.
If the tear down being added is a subscription that is already
unsubscribed, is the same reference add is being called on, or is
Subscription.EMPTY, it will not be added.
If this subscription is already in an isUnsubscribed state, the passed
tear down logic will be executed immediately.
The additional logic to execute on teardown.
Returns the Subscription used or created to be
added to the inner subscriptions list. This Subscription can be used with
remove() to remove the passed teardown logic from the inner subscriptions
list.
The Observer callback to receive a valueless notification of type
complete from the Observable. Notifies the Observer that the Observable
has finished sending push-based notifications.
The Observer callback to receive notifications of type next from
the Observable, with a value. The Observable may call this method 0 or more
times.
Removes a Subscription from the internal list of subscriptions that will unsubscribe during the unsubscribe process of this Subscription.
The subscription to remove.
A static factory for a Subscriber, given a (potentially partial) definition of an Observer.
A Subscriber wrapping the (partially defined) Observer represented by the given arguments.
Perform a side effect for every emission on the source Observable, but return an Observable that is identical to the source.
Intercepts each emission on the source and runs a function, but returns an output which is identical to the source.

Returns a mirrored Observable of the source Observable, but modified so that the provided Observer is called to perform a side effect for every value, error, and completion emitted by the source. Any errors that are thrown in the aforementioned Observer or handlers are safely sent down the error path of the output Observable.
This operator is useful for debugging your Observables for the correct values or performing other side effects.
Note: this is different to a subscribe on the Observable. If the Observable
returned by do is not subscribed, the side effects specified by the
Observer will never happen. do therefore simply spies on existing
execution, it does not trigger an execution to happen like subscribe does.
An Observable identical to the source, but runs the specified Observer or callback(s) for each item.
We need this JSDoc comment for affecting ESDoc.
A flag to indicate whether this Subscription has already been unsubscribed.
Adds a tear down to be called during the unsubscribe() of this Subscription.
If the tear down being added is a subscription that is already
unsubscribed, is the same reference add is being called on, or is
Subscription.EMPTY, it will not be added.
If this subscription is already in an isUnsubscribed state, the passed
tear down logic will be executed immediately.
The additional logic to execute on teardown.
Returns the Subscription used or created to be
added to the inner subscriptions list. This Subscription can be used with
remove() to remove the passed teardown logic from the inner subscriptions
list.
The Observer callback to receive a valueless notification of type
complete from the Observable. Notifies the Observer that the Observable
has finished sending push-based notifications.
The Observer callback to receive notifications of type next from
the Observable, with a value. The Observable may call this method 0 or more
times.
Removes a Subscription from the internal list of subscriptions that will unsubscribe during the unsubscribe process of this Subscription.
The subscription to remove.
A static factory for a Subscriber, given a (potentially partial) definition of an Observer.
A Subscriber wrapping the (partially defined) Observer represented by the given arguments.
Returns an Observable that emits the item at the specified index in the source Observable. If default is given, missing indices will output this value on next; otherwise, outputs error.
the index of the value to be retrieved.
an Observable that emits a single item, if it is found. Otherwise, will emit the default value if given.
We need this JSDoc comment for affecting ESDoc.
A flag to indicate whether this Subscription has already been unsubscribed.
Adds a tear down to be called during the unsubscribe() of this Subscription.
If the tear down being added is a subscription that is already
unsubscribed, is the same reference add is being called on, or is
Subscription.EMPTY, it will not be added.
If this subscription is already in an isUnsubscribed state, the passed
tear down logic will be executed immediately.
The additional logic to execute on teardown.
Returns the Subscription used or created to be
added to the inner subscriptions list. This Subscription can be used with
remove() to remove the passed teardown logic from the inner subscriptions
list.
The Observer callback to receive a valueless notification of type
complete from the Observable. Notifies the Observer that the Observable
has finished sending push-based notifications.
The Observer callback to receive notifications of type next from
the Observable, with a value. The Observable may call this method 0 or more
times.
Removes a Subscription from the internal list of subscriptions that will unsubscribe during the unsubscribe process of this Subscription.
The subscription to remove.
A static factory for a Subscriber, given a (potentially partial) definition of an Observer.
A Subscriber wrapping the (partially defined) Observer represented by the given arguments.
Returns an Observable that emits whether or not every item of the source satisfies the condition specified.
a function for determining if an item meets a specified condition.
an Observable of booleans that determines if all items of the source Observable meet the condition specified.
We need this JSDoc comment for affecting ESDoc.
A flag to indicate whether this Subscription has already been unsubscribed.
Adds a tear down to be called during the unsubscribe() of this Subscription.
If the tear down being added is a subscription that is already
unsubscribed, is the same reference add is being called on, or is
Subscription.EMPTY, it will not be added.
If this subscription is already in an isUnsubscribed state, the passed
tear down logic will be executed immediately.
The additional logic to execute on teardown.
Returns the Subscription used or created to be
added to the inner subscriptions list. This Subscription can be used with
remove() to remove the passed teardown logic from the inner subscriptions
list.
The Observer callback to receive a valueless notification of type
complete from the Observable. Notifies the Observer that the Observable
has finished sending push-based notifications.
The Observer callback to receive notifications of type next from
the Observable, with a value. The Observable may call this method 0 or more
times.
Removes a Subscription from the internal list of subscriptions that will unsubscribe during the unsubscribe process of this Subscription.
The subscription to remove.
A static factory for a Subscriber, given a (potentially partial) definition of an Observer.
A Subscriber wrapping the (partially defined) Observer represented by the given arguments.
Converts a higher-order Observable into a first-order Observable by dropping inner Observables while the previous inner Observable has not yet completed.
Flattens an Observable-of-Observables by dropping the next inner Observables while the current inner is still executing.

exhaust subscribes to an Observable that emits Observables, also known as a
higher-order Observable. Each time it observes one of these emitted inner
Observables, the output Observable begins emitting the items emitted by that
inner Observable. So far, it behaves like mergeAll. However,
exhaust ignores every new inner Observable if the previous Observable has
not yet completed. Once that one completes, it will accept and flatten the
next inner Observable and repeat this process.
Returns an Observable that takes a source of Observables and propagates the first observable exclusively until it completes before subscribing to the next.
We need this JSDoc comment for affecting ESDoc.
A flag to indicate whether this Subscription has already been unsubscribed.
Adds a tear down to be called during the unsubscribe() of this Subscription.
If the tear down being added is a subscription that is already
unsubscribed, is the same reference add is being called on, or is
Subscription.EMPTY, it will not be added.
If this subscription is already in an isUnsubscribed state, the passed
tear down logic will be executed immediately.
The additional logic to execute on teardown.
Returns the Subscription used or created to be
added to the inner subscriptions list. This Subscription can be used with
remove() to remove the passed teardown logic from the inner subscriptions
list.
The Observer callback to receive a valueless notification of type
complete from the Observable. Notifies the Observer that the Observable
has finished sending push-based notifications.
The Observer callback to receive notifications of type next from
the Observable, with a value. The Observable may call this method 0 or more
times.
Removes a Subscription from the internal list of subscriptions that will unsubscribe during the unsubscribe process of this Subscription.
The subscription to remove.
A static factory for a Subscriber, given a (potentially partial) definition of an Observer.
A Subscriber wrapping the (partially defined) Observer represented by the given arguments.
Projects each source value to an Observable which is merged in the output Observable only if the previous projected Observable has completed.
Maps each value to an Observable, then flattens all of these inner Observables using exhaust.

Returns an Observable that emits items based on applying a function that you
supply to each item emitted by the source Observable, where that function
returns an (so-called "inner") Observable. When it projects a source value to
an Observable, the output Observable begins emitting the items emitted by
that projected Observable. However, exhaustMap ignores every new projected
Observable if the previous projected Observable has not yet completed. Once
that one completes, it will accept and flatten the next projected Observable
and repeat this process.
A function that, when applied to an item emitted by the source Observable, returns an Observable.
An Observable containing projected Observables of each item of the source, ignoring projected Observables that start before their preceding Observable has completed.
We need this JSDoc comment for affecting ESDoc.
A flag to indicate whether this Subscription has already been unsubscribed.
Adds a tear down to be called during the unsubscribe() of this Subscription.
If the tear down being added is a subscription that is already
unsubscribed, is the same reference add is being called on, or is
Subscription.EMPTY, it will not be added.
If this subscription is already in an isUnsubscribed state, the passed
tear down logic will be executed immediately.
The additional logic to execute on teardown.
Returns the Subscription used or created to be
added to the inner subscriptions list. This Subscription can be used with
remove() to remove the passed teardown logic from the inner subscriptions
list.
The Observer callback to receive a valueless notification of type
complete from the Observable. Notifies the Observer that the Observable
has finished sending push-based notifications.
The Observer callback to receive notifications of type next from
the Observable, with a value. The Observable may call this method 0 or more
times.
Removes a Subscription from the internal list of subscriptions that will unsubscribe during the unsubscribe process of this Subscription.
The subscription to remove.
A static factory for a Subscriber, given a (potentially partial) definition of an Observer.
A Subscriber wrapping the (partially defined) Observer represented by the given arguments.
Returns an Observable where for each item in the source Observable, the supplied function is applied to each item, resulting in a new value to then be applied again with the function.
the function for projecting the next emitted item of the Observable.
an Observable containing the expansions of the source Observable.
We need this JSDoc comment for affecting ESDoc.
A flag to indicate whether this Subscription has already been unsubscribed.
Adds a tear down to be called during the unsubscribe() of this Subscription.
If the tear down being added is a subscription that is already
unsubscribed, is the same reference add is being called on, or is
Subscription.EMPTY, it will not be added.
If this subscription is already in an isUnsubscribed state, the passed
tear down logic will be executed immediately.
The additional logic to execute on teardown.
Returns the Subscription used or created to be
added to the inner subscriptions list. This Subscription can be used with
remove() to remove the passed teardown logic from the inner subscriptions
list.
The Observer callback to receive a valueless notification of type
complete from the Observable. Notifies the Observer that the Observable
has finished sending push-based notifications.
The Observer callback to receive notifications of type next from
the Observable, with a value. The Observable may call this method 0 or more
times.
Removes a Subscription from the internal list of subscriptions that will unsubscribe during the unsubscribe process of this Subscription.
The subscription to remove.
A static factory for a Subscriber, given a (potentially partial) definition of an Observer.
A Subscriber wrapping the (partially defined) Observer represented by the given arguments.
Filter items emitted by the source Observable by only emitting those that satisfy a specified predicate.
Like Array.prototype.filter(), it only emits a value from the source if it passes a criterion function.

Similar to the well-known Array.prototype.filter method, this operator
takes values from the source Observable, passes them through a predicate
function and only emits those values that yielded true.
A function that
evaluates each value emitted by the source Observable. If it returns true,
the value is emitted, if false the value is not passed to the output
Observable. The index parameter is the number i for the i-th source
emission that has happened since the subscription, starting from the number
0.
An Observable of values from the source that were
allowed by the predicate function.
We need this JSDoc comment for affecting ESDoc.
A flag to indicate whether this Subscription has already been unsubscribed.
Adds a tear down to be called during the unsubscribe() of this Subscription.
If the tear down being added is a subscription that is already
unsubscribed, is the same reference add is being called on, or is
Subscription.EMPTY, it will not be added.
If this subscription is already in an isUnsubscribed state, the passed
tear down logic will be executed immediately.
The additional logic to execute on teardown.
Returns the Subscription used or created to be
added to the inner subscriptions list. This Subscription can be used with
remove() to remove the passed teardown logic from the inner subscriptions
list.
The Observer callback to receive a valueless notification of type
complete from the Observable. Notifies the Observer that the Observable
has finished sending push-based notifications.
The Observer callback to receive notifications of type next from
the Observable, with a value. The Observable may call this method 0 or more
times.
Removes a Subscription from the internal list of subscriptions that will unsubscribe during the unsubscribe process of this Subscription.
The subscription to remove.
A static factory for a Subscriber, given a (potentially partial) definition of an Observer.
A Subscriber wrapping the (partially defined) Observer represented by the given arguments.
Returns an Observable that mirrors the source Observable, but will call a specified function when the source terminates on complete or error.
function to be called when source terminates.
an Observable that mirrors the source, but will call the specified function on termination.
We need this JSDoc comment for affecting ESDoc.
A flag to indicate whether this Subscription has already been unsubscribed.
Adds a tear down to be called during the unsubscribe() of this Subscription.
If the tear down being added is a subscription that is already
unsubscribed, is the same reference add is being called on, or is
Subscription.EMPTY, it will not be added.
If this subscription is already in an isUnsubscribed state, the passed
tear down logic will be executed immediately.
The additional logic to execute on teardown.
Returns the Subscription used or created to be
added to the inner subscriptions list. This Subscription can be used with
remove() to remove the passed teardown logic from the inner subscriptions
list.
The Observer callback to receive a valueless notification of type
complete from the Observable. Notifies the Observer that the Observable
has finished sending push-based notifications.
The Observer callback to receive notifications of type next from
the Observable, with a value. The Observable may call this method 0 or more
times.
Removes a Subscription from the internal list of subscriptions that will unsubscribe during the unsubscribe process of this Subscription.
The subscription to remove.
A static factory for a Subscriber, given a (potentially partial) definition of an Observer.
A Subscriber wrapping the (partially defined) Observer represented by the given arguments.
Emits only the first value emitted by the source Observable that meets some condition.
Finds the first value that passes some test and emits that.

find searches for the first item in the source Observable that matches the
specified condition embodied by the predicate, and returns the first
occurrence in the source. Unlike first, the predicate is required
in find, and does not emit an error if a valid value is not found.
A function called with each item to test for condition matching.
An Observable of the first item that matches the condition.
Emits only the index of the first value emitted by the source Observable that meets some condition.
It's like find, but emits the index of the found value, not the value itself.

findIndex searches for the first item in the source Observable that matches
the specified condition embodied by the predicate, and returns the
(zero-based) index of the first occurrence in the source. Unlike
first, the predicate is required in findIndex, and does not emit
an error if a valid value is not found.
A function called with each item to test for condition matching.
An Observable of the index of the first item that matches the condition.
We need this JSDoc comment for affecting ESDoc.
A flag to indicate whether this Subscription has already been unsubscribed.
Adds a tear down to be called during the unsubscribe() of this Subscription.
If the tear down being added is a subscription that is already
unsubscribed, is the same reference add is being called on, or is
Subscription.EMPTY, it will not be added.
If this subscription is already in an isUnsubscribed state, the passed
tear down logic will be executed immediately.
The additional logic to execute on teardown.
Returns the Subscription used or created to be
added to the inner subscriptions list. This Subscription can be used with
remove() to remove the passed teardown logic from the inner subscriptions
list.
The Observer callback to receive a valueless notification of type
complete from the Observable. Notifies the Observer that the Observable
has finished sending push-based notifications.
The Observer callback to receive notifications of type next from
the Observable, with a value. The Observable may call this method 0 or more
times.
Removes a Subscription from the internal list of subscriptions that will unsubscribe during the unsubscribe process of this Subscription.
The subscription to remove.
A static factory for a Subscriber, given a (potentially partial) definition of an Observer.
A Subscriber wrapping the (partially defined) Observer represented by the given arguments.
Emits only the first value (or the first value that meets some condition) emitted by the source Observable.
Emits only the first value. Or emits only the first value that passes some test.

If called with no arguments, first emits the first value of the source
Observable, then completes. If called with a predicate function, first
emits the first value of the source that matches the specified condition. It
may also take a resultSelector function to produce the output value from
the input value, and a defaultValue to emit in case the source completes
before it is able to emit a valid value. Throws an error if defaultValue
was not provided and a matching element is not found.
an Observable of the first item that matches the condition.
We need this JSDoc comment for affecting ESDoc.
A flag to indicate whether this Subscription has already been unsubscribed.
Adds a tear down to be called during the unsubscribe() of this Subscription.
If the tear down being added is a subscription that is already
unsubscribed, is the same reference add is being called on, or is
Subscription.EMPTY, it will not be added.
If this subscription is already in an isUnsubscribed state, the passed
tear down logic will be executed immediately.
The additional logic to execute on teardown.
Returns the Subscription used or created to be
added to the inner subscriptions list. This Subscription can be used with
remove() to remove the passed teardown logic from the inner subscriptions
list.
The Observer callback to receive a valueless notification of type
complete from the Observable. Notifies the Observer that the Observable
has finished sending push-based notifications.
The Observer callback to receive notifications of type next from
the Observable, with a value. The Observable may call this method 0 or more
times.
Removes a Subscription from the internal list of subscriptions that will unsubscribe during the unsubscribe process of this Subscription.
The subscription to remove.
A static factory for a Subscriber, given a (potentially partial) definition of an Observer.
A Subscriber wrapping the (partially defined) Observer represented by the given arguments.
We need this JSDoc comment for affecting ESDoc.
A flag to indicate whether this Subscription has already been unsubscribed.
Adds a tear down to be called during the unsubscribe() of this Subscription.
If the tear down being added is a subscription that is already
unsubscribed, is the same reference add is being called on, or is
Subscription.EMPTY, it will not be added.
If this subscription is already in an isUnsubscribed state, the passed
tear down logic will be executed immediately.
The additional logic to execute on teardown.
Returns the Subscription used or created to be
added to the inner subscriptions list. This Subscription can be used with
remove() to remove the passed teardown logic from the inner subscriptions
list.
The Observer callback to receive a valueless notification of type
complete from the Observable. Notifies the Observer that the Observable
has finished sending push-based notifications.
The Observer callback to receive notifications of type next from
the Observable, with a value. The Observable may call this method 0 or more
times.
Removes a Subscription from the internal list of subscriptions that will unsubscribe during the unsubscribe process of this Subscription.
The subscription to remove.
A static factory for a Subscriber, given a (potentially partial) definition of an Observer.
A Subscriber wrapping the (partially defined) Observer represented by the given arguments.
An Observable representing values belonging to the same group represented by
a common key. The values emitted by a GroupedObservable come from the source
Observable. The common key is available as the field key on a
GroupedObservable instance.
An interop point defined by the es7-observable spec https://github.com/zenparsing/es-observable
this instance of the observable
a handler for each value emitted by the observable
a promise that either resolves on observable completion or rejects with the handled error
Creates a new Observable, with this Observable as the source, and the passed operator defined as the new observable's operator.
the operator defining the operation to take on the observable
a new observable with the Operator applied
Registers handlers for handling emitted values, error and completions from the observable, and executes the observable's subscriber function, which will take action to set up the underlying data stream
(optional) either an observer defining all functions to be called, or the first of three possible handlers, which is the handler for each value emitted from the observable.
(optional) a handler for a terminal event resulting from an error. If no error handler is provided, the error will be thrown as unhandled
(optional) a handler for a terminal event resulting from successful completion.
a subscription reference to the registered handlers
Creates a new cold Observable by calling the Observable constructor
a new cold observable
We need this JSDoc comment for affecting ESDoc.
A flag to indicate whether this Subscription has already been unsubscribed.
Adds a tear down to be called during the unsubscribe() of this Subscription.
If the tear down being added is a subscription that is already
unsubscribed, is the same reference add is being called on, or is
Subscription.EMPTY, it will not be added.
If this subscription is already in an isUnsubscribed state, the passed
tear down logic will be executed immediately.
The additional logic to execute on teardown.
Returns the Subscription used or created to be
added to the inner subscriptions list. This Subscription can be used with
remove() to remove the passed teardown logic from the inner subscriptions
list.
Removes a Subscription from the internal list of subscriptions that will unsubscribe during the unsubscribe process of this Subscription.
The subscription to remove.
Groups the items emitted by an Observable according to a specified criterion,
and emits these grouped items as GroupedObservables, one
GroupedObservable per group.

a function that extracts the key for each item.
an Observable that emits GroupedObservables, each of which corresponds to a unique key value and each of which emits those items from the source Observable that share that key value.
We need this JSDoc comment for affecting ESDoc.
A flag to indicate whether this Subscription has already been unsubscribed.
Adds a tear down to be called during the unsubscribe() of this Subscription.
If the tear down being added is a subscription that is already
unsubscribed, is the same reference add is being called on, or is
Subscription.EMPTY, it will not be added.
If this subscription is already in an isUnsubscribed state, the passed
tear down logic will be executed immediately.
The additional logic to execute on teardown.
Returns the Subscription used or created to be
added to the inner subscriptions list. This Subscription can be used with
remove() to remove the passed teardown logic from the inner subscriptions
list.
The Observer callback to receive a valueless notification of type
complete from the Observable. Notifies the Observer that the Observable
has finished sending push-based notifications.
The Observer callback to receive notifications of type next from
the Observable, with a value. The Observable may call this method 0 or more
times.
Removes a Subscription from the internal list of subscriptions that will unsubscribe during the unsubscribe process of this Subscription.
The subscription to remove.
A static factory for a Subscriber, given a (potentially partial) definition of an Observer.
A Subscriber wrapping the (partially defined) Observer represented by the given arguments.
Ignores all items emitted by the source Observable and only passes calls of complete or error.

an empty Observable that only calls complete
or error, based on which one is called by the source Observable.
We need this JSDoc comment for affecting ESDoc.
A flag to indicate whether this Subscription has already been unsubscribed.
Adds a tear down to be called during the unsubscribe() of this Subscription.
If the tear down being added is a subscription that is already
unsubscribed, is the same reference add is being called on, or is
Subscription.EMPTY, it will not be added.
If this subscription is already in an isUnsubscribed state, the passed
tear down logic will be executed immediately.
The additional logic to execute on teardown.
Returns the Subscription used or created to be
added to the inner subscriptions list. This Subscription can be used with
remove() to remove the passed teardown logic from the inner subscriptions
list.
The Observer callback to receive a valueless notification of type
complete from the Observable. Notifies the Observer that the Observable
has finished sending push-based notifications.
The Observer callback to receive notifications of type next from
the Observable, with a value. The Observable may call this method 0 or more
times.
Removes a Subscription from the internal list of subscriptions that will unsubscribe during the unsubscribe process of this Subscription.
The subscription to remove.
A static factory for a Subscriber, given a (potentially partial) definition of an Observer.
A Subscriber wrapping the (partially defined) Observer represented by the given arguments.
If the source Observable is empty it returns an Observable that emits true, otherwise it emits false.

an Observable that emits a Boolean.
We need this JSDoc comment for affecting ESDoc.
A flag to indicate whether this Subscription has already been unsubscribed.
Adds a tear down to be called during the unsubscribe() of this Subscription.
If the tear down being added is a subscription that is already
unsubscribed, is the same reference add is being called on, or is
Subscription.EMPTY, it will not be added.
If this subscription is already in an isUnsubscribed state, the passed
tear down logic will be executed immediately.
The additional logic to execute on teardown.
Returns the Subscription used or created to be
added to the inner subscriptions list. This Subscription can be used with
remove() to remove the passed teardown logic from the inner subscriptions
list.
The Observer callback to receive a valueless notification of type
complete from the Observable. Notifies the Observer that the Observable
has finished sending push-based notifications.
The Observer callback to receive notifications of type next from
the Observable, with a value. The Observable may call this method 0 or more
times.
Removes a Subscription from the internal list of subscriptions that will unsubscribe during the unsubscribe process of this Subscription.
The subscription to remove.
A static factory for a Subscriber, given a (potentially partial) definition of an Observer.
A Subscriber wrapping the (partially defined) Observer represented by the given arguments.
Returns an Observable that emits only the last item emitted by the source Observable. It optionally takes a predicate function as a parameter, in which case, rather than emitting the last item from the source Observable, the resulting Observable will emit the last item from the source Observable that satisfies the predicate.

the condition any source emitted item has to satisfy.
an Observable that emits only the last item satisfying the given condition from the source, or an NoSuchElementException if no such items are emitted.
We need this JSDoc comment for affecting ESDoc.
A flag to indicate whether this Subscription has already been unsubscribed.
Adds a tear down to be called during the unsubscribe() of this Subscription.
If the tear down being added is a subscription that is already
unsubscribed, is the same reference add is being called on, or is
Subscription.EMPTY, it will not be added.
If this subscription is already in an isUnsubscribed state, the passed
tear down logic will be executed immediately.
The additional logic to execute on teardown.
Returns the Subscription used or created to be
added to the inner subscriptions list. This Subscription can be used with
remove() to remove the passed teardown logic from the inner subscriptions
list.
The Observer callback to receive a valueless notification of type
complete from the Observable. Notifies the Observer that the Observable
has finished sending push-based notifications.
The Observer callback to receive notifications of type next from
the Observable, with a value. The Observable may call this method 0 or more
times.
Removes a Subscription from the internal list of subscriptions that will unsubscribe during the unsubscribe process of this Subscription.
The subscription to remove.
A static factory for a Subscriber, given a (potentially partial) definition of an Observer.
A Subscriber wrapping the (partially defined) Observer represented by the given arguments.
Applies a given project function to each value emitted by the source
Observable, and emits the resulting values as an Observable.
Like Array.prototype.map(), it passes each source value through a transformation function to get corresponding output values.

Similar to the well known Array.prototype.map function, this operator
applies a projection to each value and emits that projection in the output
Observable.
The function to apply
to each value emitted by the source Observable. The index parameter is
the number i for the i-th emission that has happened since the
subscription, starting from the number 0.
An Observable that emits the values from the source
Observable transformed by the given project function.
We need this JSDoc comment for affecting ESDoc.
A flag to indicate whether this Subscription has already been unsubscribed.
Adds a tear down to be called during the unsubscribe() of this Subscription.
If the tear down being added is a subscription that is already
unsubscribed, is the same reference add is being called on, or is
Subscription.EMPTY, it will not be added.
If this subscription is already in an isUnsubscribed state, the passed
tear down logic will be executed immediately.
The additional logic to execute on teardown.
Returns the Subscription used or created to be
added to the inner subscriptions list. This Subscription can be used with
remove() to remove the passed teardown logic from the inner subscriptions
list.
The Observer callback to receive a valueless notification of type
complete from the Observable. Notifies the Observer that the Observable
has finished sending push-based notifications.
The Observer callback to receive notifications of type next from
the Observable, with a value. The Observable may call this method 0 or more
times.
Removes a Subscription from the internal list of subscriptions that will unsubscribe during the unsubscribe process of this Subscription.
The subscription to remove.
A static factory for a Subscriber, given a (potentially partial) definition of an Observer.
A Subscriber wrapping the (partially defined) Observer represented by the given arguments.
Emits the given constant value on the output Observable every time the source Observable emits a value.
Like map, but it maps every source value to the same output value every time.

Takes a constant value as argument, and emits that whenever the source
Observable emits a value. In other words, ignores the actual source value,
and simply uses the emission moment to know when to emit the given value.
The value to map each source value to.
An Observable that emits the given value every time
the source Observable emits something.
We need this JSDoc comment for affecting ESDoc.
A flag to indicate whether this Subscription has already been unsubscribed.
Adds a tear down to be called during the unsubscribe() of this Subscription.
If the tear down being added is a subscription that is already
unsubscribed, is the same reference add is being called on, or is
Subscription.EMPTY, it will not be added.
If this subscription is already in an isUnsubscribed state, the passed
tear down logic will be executed immediately.
The additional logic to execute on teardown.
Returns the Subscription used or created to be
added to the inner subscriptions list. This Subscription can be used with
remove() to remove the passed teardown logic from the inner subscriptions
list.
The Observer callback to receive a valueless notification of type
complete from the Observable. Notifies the Observer that the Observable
has finished sending push-based notifications.
The Observer callback to receive notifications of type next from
the Observable, with a value. The Observable may call this method 0 or more
times.
Removes a Subscription from the internal list of subscriptions that will unsubscribe during the unsubscribe process of this Subscription.
The subscription to remove.
A static factory for a Subscriber, given a (potentially partial) definition of an Observer.
A Subscriber wrapping the (partially defined) Observer represented by the given arguments.
Returns an Observable that represents all of the emissions and notifications
from the source Observable into emissions marked with their original types
within a Notification objects.

an Observable that emits items that are the result of materializing the items and notifications of the source Observable.
The Max operator operates on an Observable that emits numbers (or items that can be evaluated as numbers), and when source Observable completes it emits a single item: the item with the largest number.

an Observable that emits item with the largest number.
Creates an output Observable which concurrently emits all values from every given input Observable.
Flattens multiple Observables together by blending their values into one Observable.

merge subscribes to each given input Observable (either the source or an
Observable given as argument), and simply forwards (without doing any
transformation) all the values from all the input Observables to the output
Observable. The output Observable only completes once all input Observables
have completed. Any error delivered by an input Observable will be immediately
emitted on the output Observable.
an Observable that emits items that are the result of every input Observable.
Creates an output Observable which concurrently emits all values from every given input Observable.
Flattens multiple Observables together by blending their values into one Observable.

merge subscribes to each given input Observable (as arguments), and simply
forwards (without doing any transformation) all the values from all the input
Observables to the output Observable. The output Observable only completes
once all input Observables have completed. Any error delivered by an input
Observable will be immediately emitted on the output Observable.
an Observable that emits items that are the result of every input Observable.
Creates an output Observable which concurrently emits all values from every given input Observable.
Flattens multiple Observables together by blending their values into one Observable.

merge subscribes to each given input Observable (as arguments), and simply
forwards (without doing any transformation) all the values from all the input
Observables to the output Observable. The output Observable only completes
once all input Observables have completed. Any error delivered by an input
Observable will be immediately emitted on the output Observable.
an Observable that emits items that are the result of every input Observable.
Creates an output Observable which concurrently emits all values from every given input Observable.
Flattens multiple Observables together by blending their values into one Observable.

merge subscribes to each given input Observable (as arguments), and simply
forwards (without doing any transformation) all the values from all the input
Observables to the output Observable. The output Observable only completes
once all input Observables have completed. Any error delivered by an input
Observable will be immediately emitted on the output Observable.
an Observable that emits items that are the result of every input Observable.
Creates an output Observable which concurrently emits all values from every given input Observable.
Flattens multiple Observables together by blending their values into one Observable.

merge subscribes to each given input Observable (as arguments), and simply
forwards (without doing any transformation) all the values from all the input
Observables to the output Observable. The output Observable only completes
once all input Observables have completed. Any error delivered by an input
Observable will be immediately emitted on the output Observable.
an Observable that emits items that are the result of every input Observable.
Creates an output Observable which concurrently emits all values from every given input Observable.
Flattens multiple Observables together by blending their values into one Observable.

merge subscribes to each given input Observable (as arguments), and simply
forwards (without doing any transformation) all the values from all the input
Observables to the output Observable. The output Observable only completes
once all input Observables have completed. Any error delivered by an input
Observable will be immediately emitted on the output Observable.
an Observable that emits items that are the result of every input Observable.
Creates an output Observable which concurrently emits all values from every given input Observable.
Flattens multiple Observables together by blending their values into one Observable.

merge subscribes to each given input Observable (as arguments), and simply
forwards (without doing any transformation) all the values from all the input
Observables to the output Observable. The output Observable only completes
once all input Observables have completed. Any error delivered by an input
Observable will be immediately emitted on the output Observable.
an Observable that emits items that are the result of every input Observable.
Creates an output Observable which concurrently emits all values from every given input Observable.
Flattens multiple Observables together by blending their values into one Observable.

merge subscribes to each given input Observable (as arguments), and simply
forwards (without doing any transformation) all the values from all the input
Observables to the output Observable. The output Observable only completes
once all input Observables have completed. Any error delivered by an input
Observable will be immediately emitted on the output Observable.
an Observable that emits items that are the result of every input Observable.
Creates an output Observable which concurrently emits all values from every given input Observable.
Flattens multiple Observables together by blending their values into one Observable.

merge subscribes to each given input Observable (as arguments), and simply
forwards (without doing any transformation) all the values from all the input
Observables to the output Observable. The output Observable only completes
once all input Observables have completed. Any error delivered by an input
Observable will be immediately emitted on the output Observable.
an Observable that emits items that are the result of every input Observable.
Creates an output Observable which concurrently emits all values from every given input Observable.
Flattens multiple Observables together by blending their values into one Observable.

merge subscribes to each given input Observable (as arguments), and simply
forwards (without doing any transformation) all the values from all the input
Observables to the output Observable. The output Observable only completes
once all input Observables have completed. Any error delivered by an input
Observable will be immediately emitted on the output Observable.
an Observable that emits items that are the result of every input Observable.
Creates an output Observable which concurrently emits all values from every given input Observable.
Flattens multiple Observables together by blending their values into one Observable.

merge subscribes to each given input Observable (as arguments), and simply
forwards (without doing any transformation) all the values from all the input
Observables to the output Observable. The output Observable only completes
once all input Observables have completed. Any error delivered by an input
Observable will be immediately emitted on the output Observable.
an Observable that emits items that are the result of every input Observable.
Creates an output Observable which concurrently emits all values from every given input Observable.
Flattens multiple Observables together by blending their values into one Observable.

merge subscribes to each given input Observable (as arguments), and simply
forwards (without doing any transformation) all the values from all the input
Observables to the output Observable. The output Observable only completes
once all input Observables have completed. Any error delivered by an input
Observable will be immediately emitted on the output Observable.
an Observable that emits items that are the result of every input Observable.
Creates an output Observable which concurrently emits all values from every given input Observable.
Flattens multiple Observables together by blending their values into one Observable.

merge subscribes to each given input Observable (as arguments), and simply
forwards (without doing any transformation) all the values from all the input
Observables to the output Observable. The output Observable only completes
once all input Observables have completed. Any error delivered by an input
Observable will be immediately emitted on the output Observable.
an Observable that emits items that are the result of every input Observable.
Creates an output Observable which concurrently emits all values from every given input Observable.
Flattens multiple Observables together by blending their values into one Observable.

merge subscribes to each given input Observable (as arguments), and simply
forwards (without doing any transformation) all the values from all the input
Observables to the output Observable. The output Observable only completes
once all input Observables have completed. Any error delivered by an input
Observable will be immediately emitted on the output Observable.
an Observable that emits items that are the result of every input Observable.
Creates an output Observable which concurrently emits all values from every given input Observable.
Flattens multiple Observables together by blending their values into one Observable.

merge subscribes to each given input Observable (as arguments), and simply
forwards (without doing any transformation) all the values from all the input
Observables to the output Observable. The output Observable only completes
once all input Observables have completed. Any error delivered by an input
Observable will be immediately emitted on the output Observable.
an Observable that emits items that are the result of every input Observable.
We need this JSDoc comment for affecting ESDoc.
A flag to indicate whether this Subscription has already been unsubscribed.
Adds a tear down to be called during the unsubscribe() of this Subscription.
If the tear down being added is a subscription that is already
unsubscribed, is the same reference add is being called on, or is
Subscription.EMPTY, it will not be added.
If this subscription is already in an isUnsubscribed state, the passed
tear down logic will be executed immediately.
The additional logic to execute on teardown.
Returns the Subscription used or created to be
added to the inner subscriptions list. This Subscription can be used with
remove() to remove the passed teardown logic from the inner subscriptions
list.
The Observer callback to receive a valueless notification of type
complete from the Observable. Notifies the Observer that the Observable
has finished sending push-based notifications.
The Observer callback to receive notifications of type next from
the Observable, with a value. The Observable may call this method 0 or more
times.
Removes a Subscription from the internal list of subscriptions that will unsubscribe during the unsubscribe process of this Subscription.
The subscription to remove.
A static factory for a Subscriber, given a (potentially partial) definition of an Observer.
A Subscriber wrapping the (partially defined) Observer represented by the given arguments.
Converts a higher-order Observable into a first-order Observable which concurrently delivers all values that are emitted on the inner Observables.
Flattens an Observable-of-Observables.

mergeAll subscribes to an Observable that emits Observables, also known as
a higher-order Observable. Each time it observes one of these emitted inner
Observables, it subscribes to that and delivers all the values from the
inner Observable on the output Observable. The output Observable only
completes once all inner Observables have completed. Any error delivered by
a inner Observable will be immediately emitted on the output Observable.
An Observable that emits values coming from all the inner Observables emitted by the source Observable.
We need this JSDoc comment for affecting ESDoc.
A flag to indicate whether this Subscription has already been unsubscribed.
Adds a tear down to be called during the unsubscribe() of this Subscription.
If the tear down being added is a subscription that is already
unsubscribed, is the same reference add is being called on, or is
Subscription.EMPTY, it will not be added.
If this subscription is already in an isUnsubscribed state, the passed
tear down logic will be executed immediately.
The additional logic to execute on teardown.
Returns the Subscription used or created to be
added to the inner subscriptions list. This Subscription can be used with
remove() to remove the passed teardown logic from the inner subscriptions
list.
The Observer callback to receive a valueless notification of type
complete from the Observable. Notifies the Observer that the Observable
has finished sending push-based notifications.
The Observer callback to receive notifications of type next from
the Observable, with a value. The Observable may call this method 0 or more
times.
Removes a Subscription from the internal list of subscriptions that will unsubscribe during the unsubscribe process of this Subscription.
The subscription to remove.
A static factory for a Subscriber, given a (potentially partial) definition of an Observer.
A Subscriber wrapping the (partially defined) Observer represented by the given arguments.
Projects each source value to an Observable which is merged in the output Observable.
Maps each value to an Observable, then flattens all of these inner Observables using mergeAll.

Returns an Observable that emits items based on applying a function that you supply to each item emitted by the source Observable, where that function returns an Observable, and then merging those resulting Observables and emitting the results of this merger.
A function that, when applied to an item emitted by the source Observable, returns an Observable.
An Observable that emits the result of applying the
projection function (and the optional resultSelector) to each item emitted
by the source Observable and merging the results of the Observables obtained
from this transformation.
We need this JSDoc comment for affecting ESDoc.
A flag to indicate whether this Subscription has already been unsubscribed.
Adds a tear down to be called during the unsubscribe() of this Subscription.
If the tear down being added is a subscription that is already
unsubscribed, is the same reference add is being called on, or is
Subscription.EMPTY, it will not be added.
If this subscription is already in an isUnsubscribed state, the passed
tear down logic will be executed immediately.
The additional logic to execute on teardown.
Returns the Subscription used or created to be
added to the inner subscriptions list. This Subscription can be used with
remove() to remove the passed teardown logic from the inner subscriptions
list.
The Observer callback to receive a valueless notification of type
complete from the Observable. Notifies the Observer that the Observable
has finished sending push-based notifications.
The Observer callback to receive notifications of type next from
the Observable, with a value. The Observable may call this method 0 or more
times.
Removes a Subscription from the internal list of subscriptions that will unsubscribe during the unsubscribe process of this Subscription.
The subscription to remove.
A static factory for a Subscriber, given a (potentially partial) definition of an Observer.
A Subscriber wrapping the (partially defined) Observer represented by the given arguments.
Projects each source value to the same Observable which is merged multiple times in the output Observable.
It's like mergeMap, but maps each value always to the same inner Observable.

Maps each source value to the given Observable innerObservable regardless
of the source value, and then merges those resulting Observables into one
single Observable, which is the output Observable.
An Observable to replace each value from the source Observable.
An Observable that emits items from the given
innerObservable (and optionally transformed through resultSelector) every
time a value is emitted on the source Observable.
We need this JSDoc comment for affecting ESDoc.
A flag to indicate whether this Subscription has already been unsubscribed.
Adds a tear down to be called during the unsubscribe() of this Subscription.
If the tear down being added is a subscription that is already
unsubscribed, is the same reference add is being called on, or is
Subscription.EMPTY, it will not be added.
If this subscription is already in an isUnsubscribed state, the passed
tear down logic will be executed immediately.
The additional logic to execute on teardown.
Returns the Subscription used or created to be
added to the inner subscriptions list. This Subscription can be used with
remove() to remove the passed teardown logic from the inner subscriptions
list.
The Observer callback to receive a valueless notification of type
complete from the Observable. Notifies the Observer that the Observable
has finished sending push-based notifications.
The Observer callback to receive notifications of type next from
the Observable, with a value. The Observable may call this method 0 or more
times.
Removes a Subscription from the internal list of subscriptions that will unsubscribe during the unsubscribe process of this Subscription.
The subscription to remove.
A static factory for a Subscriber, given a (potentially partial) definition of an Observer.
A Subscriber wrapping the (partially defined) Observer represented by the given arguments.
The Min operator operates on an Observable that emits numbers (or items that can be evaluated as numbers), and when source Observable completes it emits a single item: the item with the smallest number.

an Observable that emits item with the smallest number.
Returns an Observable that emits the results of invoking a specified selector on items emitted by a ConnectableObservable that shares a single subscription to the underlying stream.

an Observable that emits the results of invoking the selector
on the items emitted by a ConnectableObservable that shares a single subscription to
the underlying stream.
We need this JSDoc comment for affecting ESDoc.
A flag to indicate whether this Subscription has already been unsubscribed.
Adds a tear down to be called during the unsubscribe() of this Subscription.
If the tear down being added is a subscription that is already
unsubscribed, is the same reference add is being called on, or is
Subscription.EMPTY, it will not be added.
If this subscription is already in an isUnsubscribed state, the passed
tear down logic will be executed immediately.
The additional logic to execute on teardown.
Returns the Subscription used or created to be
added to the inner subscriptions list. This Subscription can be used with
remove() to remove the passed teardown logic from the inner subscriptions
list.
The Observer callback to receive a valueless notification of type
complete from the Observable. Notifies the Observer that the Observable
has finished sending push-based notifications.
The Observer callback to receive notifications of type next from
the Observable, with a value. The Observable may call this method 0 or more
times.
Removes a Subscription from the internal list of subscriptions that will unsubscribe during the unsubscribe process of this Subscription.
The subscription to remove.
A static factory for a Subscriber, given a (potentially partial) definition of an Observer.
A Subscriber wrapping the (partially defined) Observer represented by the given arguments.
We need this JSDoc comment for affecting ESDoc.
A flag to indicate whether this Subscription has already been unsubscribed.
Adds a tear down to be called during the unsubscribe() of this Subscription.
If the tear down being added is a subscription that is already
unsubscribed, is the same reference add is being called on, or is
Subscription.EMPTY, it will not be added.
If this subscription is already in an isUnsubscribed state, the passed
tear down logic will be executed immediately.
The additional logic to execute on teardown.
Returns the Subscription used or created to be
added to the inner subscriptions list. This Subscription can be used with
remove() to remove the passed teardown logic from the inner subscriptions
list.
The Observer callback to receive a valueless notification of type
complete from the Observable. Notifies the Observer that the Observable
has finished sending push-based notifications.
The Observer callback to receive notifications of type next from
the Observable, with a value. The Observable may call this method 0 or more
times.
Removes a Subscription from the internal list of subscriptions that will unsubscribe during the unsubscribe process of this Subscription.
The subscription to remove.
A static factory for a Subscriber, given a (potentially partial) definition of an Observer.
A Subscriber wrapping the (partially defined) Observer represented by the given arguments.
Returns a new observable that triggers on the second and following inputs. An input that triggers an event will return an pair of [(N - 1)th, Nth]. The (N-1)th is stored in the internal state until Nth input occurs.

an observable of pairs of values.
Maps each source value (an object) to its specified nested property.
Like map, but meant only for picking one of the nested properties of every emitted object.

Given a list of strings describing a path to an object property, retrieves
the value of a specified nested property from all values in the source
Observable. If a property can't be resolved, it will return undefined for
that value.
The nested properties to pluck from each source value (an object).
Returns a new Observable of property values from the source values.
Returns a ConnectableObservable, which is a variety of Observable that waits until its connect method is called before it begins emitting items to those Observers that have subscribed to it.

a ConnectableObservable that upon connection causes the source Observable to emit items to its Observers.
We need this JSDoc comment for affecting ESDoc.
A flag to indicate whether this Subscription has already been unsubscribed.
Adds a tear down to be called during the unsubscribe() of this Subscription.
If the tear down being added is a subscription that is already
unsubscribed, is the same reference add is being called on, or is
Subscription.EMPTY, it will not be added.
If this subscription is already in an isUnsubscribed state, the passed
tear down logic will be executed immediately.
The additional logic to execute on teardown.
Returns the Subscription used or created to be
added to the inner subscriptions list. This Subscription can be used with
remove() to remove the passed teardown logic from the inner subscriptions
list.
The Observer callback to receive a valueless notification of type
complete from the Observable. Notifies the Observer that the Observable
has finished sending push-based notifications.
The Observer callback to receive notifications of type next from
the Observable, with a value. The Observable may call this method 0 or more
times.
Removes a Subscription from the internal list of subscriptions that will unsubscribe during the unsubscribe process of this Subscription.
The subscription to remove.
A static factory for a Subscriber, given a (potentially partial) definition of an Observer.
A Subscriber wrapping the (partially defined) Observer represented by the given arguments.
Returns an Observable that mirrors the first source Observable to emit an item from the combination of this Observable and supplied Observables
an Observable that mirrors the output of the first Observable to emit an item.
Returns an Observable that mirrors the first source Observable to emit an item.
an Observable that mirrors the output of the first Observable to emit an item.
We need this JSDoc comment for affecting ESDoc.
A flag to indicate whether this Subscription has already been unsubscribed.
Adds a tear down to be called during the unsubscribe() of this Subscription.
If the tear down being added is a subscription that is already
unsubscribed, is the same reference add is being called on, or is
Subscription.EMPTY, it will not be added.
If this subscription is already in an isUnsubscribed state, the passed
tear down logic will be executed immediately.
The additional logic to execute on teardown.
Returns the Subscription used or created to be
added to the inner subscriptions list. This Subscription can be used with
remove() to remove the passed teardown logic from the inner subscriptions
list.
The Observer callback to receive a valueless notification of type
complete from the Observable. Notifies the Observer that the Observable
has finished sending push-based notifications.
The Observer callback to receive notifications of type next from
the Observable, with a value. The Observable may call this method 0 or more
times.
Removes a Subscription from the internal list of subscriptions that will unsubscribe during the unsubscribe process of this Subscription.
The subscription to remove.
A static factory for a Subscriber, given a (potentially partial) definition of an Observer.
A Subscriber wrapping the (partially defined) Observer represented by the given arguments.
Returns an Observable that applies a specified accumulator function to the first item emitted by a source Observable, then feeds the result of that function along with the second item emitted by the source Observable into the same function, and so on until all items have been emitted by the source Observable, and emits the final result from the final call to your function as its sole item. This technique, which is called "reduce" here, is sometimes called "aggregate," "fold," "accumulate," "compress," or "inject" in other programming contexts.

an Observable that emits a single item that is the result of accumulating the output from the items emitted by the source Observable.
We need this JSDoc comment for affecting ESDoc.
A flag to indicate whether this Subscription has already been unsubscribed.
Adds a tear down to be called during the unsubscribe() of this Subscription.
If the tear down being added is a subscription that is already
unsubscribed, is the same reference add is being called on, or is
Subscription.EMPTY, it will not be added.
If this subscription is already in an isUnsubscribed state, the passed
tear down logic will be executed immediately.
The additional logic to execute on teardown.
Returns the Subscription used or created to be
added to the inner subscriptions list. This Subscription can be used with
remove() to remove the passed teardown logic from the inner subscriptions
list.
The Observer callback to receive notifications of type next from
the Observable, with a value. The Observable may call this method 0 or more
times.
Removes a Subscription from the internal list of subscriptions that will unsubscribe during the unsubscribe process of this Subscription.
The subscription to remove.
A static factory for a Subscriber, given a (potentially partial) definition of an Observer.
A Subscriber wrapping the (partially defined) Observer represented by the given arguments.
Returns an Observable that repeats the stream of items emitted by the source Observable at most count times, on a particular Scheduler.

an Observable that repeats the stream of items emitted by the source Observable at most count times.
We need this JSDoc comment for affecting ESDoc.
A flag to indicate whether this Subscription has already been unsubscribed.
Adds a tear down to be called during the unsubscribe() of this Subscription.
If the tear down being added is a subscription that is already
unsubscribed, is the same reference add is being called on, or is
Subscription.EMPTY, it will not be added.
If this subscription is already in an isUnsubscribed state, the passed
tear down logic will be executed immediately.
The additional logic to execute on teardown.
Returns the Subscription used or created to be
added to the inner subscriptions list. This Subscription can be used with
remove() to remove the passed teardown logic from the inner subscriptions
list.
The Observer callback to receive a valueless notification of type
complete from the Observable. Notifies the Observer that the Observable
has finished sending push-based notifications.
The Observer callback to receive notifications of type next from
the Observable, with a value. The Observable may call this method 0 or more
times.
Removes a Subscription from the internal list of subscriptions that will unsubscribe during the unsubscribe process of this Subscription.
The subscription to remove.
A static factory for a Subscriber, given a (potentially partial) definition of an Observer.
A Subscriber wrapping the (partially defined) Observer represented by the given arguments.
Returns an Observable that mirrors the source Observable, resubscribing to it if it calls error and the
predicate returns true for that specific exception and retry count.
If the source Observable calls error, this method will resubscribe to the source Observable for a maximum of
count resubscriptions (given as a number parameter) rather than propagating the error call.

Any and all items emitted by the source Observable will be emitted by the resulting Observable, even those emitted
during failed subscriptions. For example, if an Observable fails at first but emits [1, 2] then succeeds the second
time and emits: [1, 2, 3, 4, 5] then the complete stream of emissions and notifications
would be: [1, 2, 1, 2, 3, 4, 5, complete].
the source Observable modified with the retry logic.
We need this JSDoc comment for affecting ESDoc.
A flag to indicate whether this Subscription has already been unsubscribed.
Adds a tear down to be called during the unsubscribe() of this Subscription.
If the tear down being added is a subscription that is already
unsubscribed, is the same reference add is being called on, or is
Subscription.EMPTY, it will not be added.
If this subscription is already in an isUnsubscribed state, the passed
tear down logic will be executed immediately.
The additional logic to execute on teardown.
Returns the Subscription used or created to be
added to the inner subscriptions list. This Subscription can be used with
remove() to remove the passed teardown logic from the inner subscriptions
list.
The Observer callback to receive a valueless notification of type
complete from the Observable. Notifies the Observer that the Observable
has finished sending push-based notifications.
The Observer callback to receive notifications of type next from
the Observable, with a value. The Observable may call this method 0 or more
times.
Removes a Subscription from the internal list of subscriptions that will unsubscribe during the unsubscribe process of this Subscription.
The subscription to remove.
A static factory for a Subscriber, given a (potentially partial) definition of an Observer.
A Subscriber wrapping the (partially defined) Observer represented by the given arguments.
Returns an Observable that emits the same values as the source observable with the exception of an error.
An error will cause the emission of the Throwable that cause the error to the Observable returned from
notificationHandler. If that Observable calls onComplete or error then retry will call complete or error
on the child subscription. Otherwise, this Observable will resubscribe to the source observable, on a particular
Scheduler.

the source Observable modified with retry logic.
We need this JSDoc comment for affecting ESDoc.
A flag to indicate whether this Subscription has already been unsubscribed.
Adds a tear down to be called during the unsubscribe() of this Subscription.
If the tear down being added is a subscription that is already
unsubscribed, is the same reference add is being called on, or is
Subscription.EMPTY, it will not be added.
If this subscription is already in an isUnsubscribed state, the passed
tear down logic will be executed immediately.
The additional logic to execute on teardown.
Returns the Subscription used or created to be
added to the inner subscriptions list. This Subscription can be used with
remove() to remove the passed teardown logic from the inner subscriptions
list.
The Observer callback to receive a valueless notification of type
complete from the Observable. Notifies the Observer that the Observable
has finished sending push-based notifications.
The Observer callback to receive notifications of type next from
the Observable, with a value. The Observable may call this method 0 or more
times.
Removes a Subscription from the internal list of subscriptions that will unsubscribe during the unsubscribe process of this Subscription.
The subscription to remove.
A static factory for a Subscriber, given a (potentially partial) definition of an Observer.
A Subscriber wrapping the (partially defined) Observer represented by the given arguments.
Returns an Observable that, when the specified sampler Observable emits an item or completes, it then emits the most recently emitted item (if any) emitted by the source Observable since the previous emission from the sampler Observable.

an Observable that emits the results of sampling the items emitted by this Observable whenever the sampler Observable emits an item or completes.
We need this JSDoc comment for affecting ESDoc.
A flag to indicate whether this Subscription has already been unsubscribed.
Adds a tear down to be called during the unsubscribe() of this Subscription.
If the tear down being added is a subscription that is already
unsubscribed, is the same reference add is being called on, or is
Subscription.EMPTY, it will not be added.
If this subscription is already in an isUnsubscribed state, the passed
tear down logic will be executed immediately.
The additional logic to execute on teardown.
Returns the Subscription used or created to be
added to the inner subscriptions list. This Subscription can be used with
remove() to remove the passed teardown logic from the inner subscriptions
list.
The Observer callback to receive a valueless notification of type
complete from the Observable. Notifies the Observer that the Observable
has finished sending push-based notifications.
The Observer callback to receive notifications of type next from
the Observable, with a value. The Observable may call this method 0 or more
times.
Removes a Subscription from the internal list of subscriptions that will unsubscribe during the unsubscribe process of this Subscription.
The subscription to remove.
A static factory for a Subscriber, given a (potentially partial) definition of an Observer.
A Subscriber wrapping the (partially defined) Observer represented by the given arguments.
We need this JSDoc comment for affecting ESDoc.
A flag to indicate whether this Subscription has already been unsubscribed.
Adds a tear down to be called during the unsubscribe() of this Subscription.
If the tear down being added is a subscription that is already
unsubscribed, is the same reference add is being called on, or is
Subscription.EMPTY, it will not be added.
If this subscription is already in an isUnsubscribed state, the passed
tear down logic will be executed immediately.
The additional logic to execute on teardown.
Returns the Subscription used or created to be
added to the inner subscriptions list. This Subscription can be used with
remove() to remove the passed teardown logic from the inner subscriptions
list.
The Observer callback to receive a valueless notification of type
complete from the Observable. Notifies the Observer that the Observable
has finished sending push-based notifications.
The Observer callback to receive notifications of type next from
the Observable, with a value. The Observable may call this method 0 or more
times.
Removes a Subscription from the internal list of subscriptions that will unsubscribe during the unsubscribe process of this Subscription.
The subscription to remove.
A static factory for a Subscriber, given a (potentially partial) definition of an Observer.
A Subscriber wrapping the (partially defined) Observer represented by the given arguments.
Applies an accumulation function over the source Observable, and returns each intermediate result, with an optional seed value.
It's like reduce, but emits the current accumulation whenever the source emits a value.

Combines together all values emitted on the source, using an accumulator function that knows how to join a new source value into the accumulation from the past. Is similar to reduce, but emits the intermediate accumulations.
Returns an Observable that applies a specified accumulator function to each
item emitted by the source Observable. If a seed value is specified, then
that value will be used as the initial value for the accumulator. If no seed
value is specified, the first item of the source is used as the seed.
The accumulator function called on each source value.
An observable of the accumulated values.
Returns a new Observable that multicasts (shares) the original Observable. As long as there is at least one
Subscriber this Observable will be subscribed and emitting data. When all subscribers have unsubscribed it will
unsubscribe from the source Observable. Because the Observable is multicasting it makes the stream hot.
This is an alias for .publish().refCount().

an Observable that upon connection causes the source Observable to emit items to its Observers
We need this JSDoc comment for affecting ESDoc.
A flag to indicate whether this Subscription has already been unsubscribed.
Adds a tear down to be called during the unsubscribe() of this Subscription.
If the tear down being added is a subscription that is already
unsubscribed, is the same reference add is being called on, or is
Subscription.EMPTY, it will not be added.
If this subscription is already in an isUnsubscribed state, the passed
tear down logic will be executed immediately.
The additional logic to execute on teardown.
Returns the Subscription used or created to be
added to the inner subscriptions list. This Subscription can be used with
remove() to remove the passed teardown logic from the inner subscriptions
list.
The Observer callback to receive a valueless notification of type
complete from the Observable. Notifies the Observer that the Observable
has finished sending push-based notifications.
The Observer callback to receive notifications of type next from
the Observable, with a value. The Observable may call this method 0 or more
times.
Removes a Subscription from the internal list of subscriptions that will unsubscribe during the unsubscribe process of this Subscription.
The subscription to remove.
A static factory for a Subscriber, given a (potentially partial) definition of an Observer.
A Subscriber wrapping the (partially defined) Observer represented by the given arguments.
Returns an Observable that emits the single item emitted by the source Observable that matches a specified predicate, if that Observable emits one such item. If the source Observable emits more than one such item or no such items, notify of an IllegalArgumentException or NoSuchElementException respectively.

an Observable that emits the single item emitted by the source Observable that matches the predicate. .
We need this JSDoc comment for affecting ESDoc.
A flag to indicate whether this Subscription has already been unsubscribed.
Adds a tear down to be called during the unsubscribe() of this Subscription.
If the tear down being added is a subscription that is already
unsubscribed, is the same reference add is being called on, or is
Subscription.EMPTY, it will not be added.
If this subscription is already in an isUnsubscribed state, the passed
tear down logic will be executed immediately.
The additional logic to execute on teardown.
Returns the Subscription used or created to be
added to the inner subscriptions list. This Subscription can be used with
remove() to remove the passed teardown logic from the inner subscriptions
list.
The Observer callback to receive a valueless notification of type
complete from the Observable. Notifies the Observer that the Observable
has finished sending push-based notifications.
The Observer callback to receive notifications of type next from
the Observable, with a value. The Observable may call this method 0 or more
times.
Removes a Subscription from the internal list of subscriptions that will unsubscribe during the unsubscribe process of this Subscription.
The subscription to remove.
A static factory for a Subscriber, given a (potentially partial) definition of an Observer.
A Subscriber wrapping the (partially defined) Observer represented by the given arguments.
Returns an Observable that skips n items emitted by an Observable.

an Observable that skips values emitted by the source Observable.
We need this JSDoc comment for affecting ESDoc.
A flag to indicate whether this Subscription has already been unsubscribed.
Adds a tear down to be called during the unsubscribe() of this Subscription.
If the tear down being added is a subscription that is already
unsubscribed, is the same reference add is being called on, or is
Subscription.EMPTY, it will not be added.
If this subscription is already in an isUnsubscribed state, the passed
tear down logic will be executed immediately.
The additional logic to execute on teardown.
Returns the Subscription used or created to be
added to the inner subscriptions list. This Subscription can be used with
remove() to remove the passed teardown logic from the inner subscriptions
list.
The Observer callback to receive a valueless notification of type
complete from the Observable. Notifies the Observer that the Observable
has finished sending push-based notifications.
The Observer callback to receive notifications of type next from
the Observable, with a value. The Observable may call this method 0 or more
times.
Removes a Subscription from the internal list of subscriptions that will unsubscribe during the unsubscribe process of this Subscription.
The subscription to remove.
A static factory for a Subscriber, given a (potentially partial) definition of an Observer.
A Subscriber wrapping the (partially defined) Observer represented by the given arguments.
Returns an Observable that skips items emitted by the source Observable until a second Observable emits an item.

an Observable that skips items from the source Observable until the second Observable emits an item, then emits the remaining items.
We need this JSDoc comment for affecting ESDoc.
A flag to indicate whether this Subscription has already been unsubscribed.
Adds a tear down to be called during the unsubscribe() of this Subscription.
If the tear down being added is a subscription that is already
unsubscribed, is the same reference add is being called on, or is
Subscription.EMPTY, it will not be added.
If this subscription is already in an isUnsubscribed state, the passed
tear down logic will be executed immediately.
The additional logic to execute on teardown.
Returns the Subscription used or created to be
added to the inner subscriptions list. This Subscription can be used with
remove() to remove the passed teardown logic from the inner subscriptions
list.
The Observer callback to receive a valueless notification of type
complete from the Observable. Notifies the Observer that the Observable
has finished sending push-based notifications.
The Observer callback to receive notifications of type next from
the Observable, with a value. The Observable may call this method 0 or more
times.
Removes a Subscription from the internal list of subscriptions that will unsubscribe during the unsubscribe process of this Subscription.
The subscription to remove.
A static factory for a Subscriber, given a (potentially partial) definition of an Observer.
A Subscriber wrapping the (partially defined) Observer represented by the given arguments.
Returns an Observable that skips all items emitted by the source Observable as long as a specified condition holds true, but emits all further source items as soon as the condition becomes false.

a function to test each item emitted from the source Observable.
an Observable that begins emitting items emitted by the source Observable when the specified predicate becomes false.
Returns an Observable that emits the items in a specified Iterable before it begins to emit items emitted by the source Observable.

an Observable that emits the items in the specified Iterable and then emits the items emitted by the source Observable.
Asynchronously subscribes Observers to this Observable on the specified Scheduler.

the source Observable modified so that its subscriptions happen on the specified Scheduler .
We need this JSDoc comment for affecting ESDoc.
A flag to indicate whether this Subscription has already been unsubscribed.
Adds a tear down to be called during the unsubscribe() of this Subscription.
If the tear down being added is a subscription that is already
unsubscribed, is the same reference add is being called on, or is
Subscription.EMPTY, it will not be added.
If this subscription is already in an isUnsubscribed state, the passed
tear down logic will be executed immediately.
The additional logic to execute on teardown.
Returns the Subscription used or created to be
added to the inner subscriptions list. This Subscription can be used with
remove() to remove the passed teardown logic from the inner subscriptions
list.
The Observer callback to receive a valueless notification of type
complete from the Observable. Notifies the Observer that the Observable
has finished sending push-based notifications.
The Observer callback to receive notifications of type next from
the Observable, with a value. The Observable may call this method 0 or more
times.
Removes a Subscription from the internal list of subscriptions that will unsubscribe during the unsubscribe process of this Subscription.
The subscription to remove.
A static factory for a Subscriber, given a (potentially partial) definition of an Observer.
A Subscriber wrapping the (partially defined) Observer represented by the given arguments.
Converts a higher-order Observable into a first-order Observable by subscribing to only the most recently emitted of those inner Observables.
Flattens an Observable-of-Observables by dropping the previous inner Observable once a new one appears.

switch subscribes to an Observable that emits Observables, also known as a
higher-order Observable. Each time it observes one of these emitted inner
Observables, the output Observable subscribes to the inner Observable and
begins emitting the items emitted by that. So far, it behaves
like mergeAll. However, when a new inner Observable is emitted,
switch unsubscribes from the earlier-emitted inner Observable and
subscribes to the new inner Observable and begins emitting items from it. It
continues to behave like this for subsequent inner Observables.
An Observable that emits the items emitted by the Observable most recently emitted by the source Observable.
We need this JSDoc comment for affecting ESDoc.
A flag to indicate whether this Subscription has already been unsubscribed.
Adds a tear down to be called during the unsubscribe() of this Subscription.
If the tear down being added is a subscription that is already
unsubscribed, is the same reference add is being called on, or is
Subscription.EMPTY, it will not be added.
If this subscription is already in an isUnsubscribed state, the passed
tear down logic will be executed immediately.
The additional logic to execute on teardown.
Returns the Subscription used or created to be
added to the inner subscriptions list. This Subscription can be used with
remove() to remove the passed teardown logic from the inner subscriptions
list.
The Observer callback to receive a valueless notification of type
complete from the Observable. Notifies the Observer that the Observable
has finished sending push-based notifications.
The Observer callback to receive notifications of type next from
the Observable, with a value. The Observable may call this method 0 or more
times.
Removes a Subscription from the internal list of subscriptions that will unsubscribe during the unsubscribe process of this Subscription.
The subscription to remove.
A static factory for a Subscriber, given a (potentially partial) definition of an Observer.
A Subscriber wrapping the (partially defined) Observer represented by the given arguments.
Projects each source value to an Observable which is merged in the output Observable, emitting values only from the most recently projected Observable.
Maps each value to an Observable, then flattens all of these inner Observables using switch.

Returns an Observable that emits items based on applying a function that you
supply to each item emitted by the source Observable, where that function
returns an (so-called "inner") Observable. Each time it observes one of these
inner Observables, the output Observable begins emitting the items emitted by
that inner Observable. When a new inner Observable is emitted, switchMap
stops emitting items from the earlier-emitted inner Observable and begins
emitting items from the new one. It continues to behave like this for
subsequent inner Observables.
A function that, when applied to an item emitted by the source Observable, returns an Observable.
An Observable that emits the result of applying the
projection function (and the optional resultSelector) to each item emitted
by the source Observable and taking only the values from the most recently
projected inner Observable.
We need this JSDoc comment for affecting ESDoc.
A flag to indicate whether this Subscription has already been unsubscribed.
Adds a tear down to be called during the unsubscribe() of this Subscription.
If the tear down being added is a subscription that is already
unsubscribed, is the same reference add is being called on, or is
Subscription.EMPTY, it will not be added.
If this subscription is already in an isUnsubscribed state, the passed
tear down logic will be executed immediately.
The additional logic to execute on teardown.
Returns the Subscription used or created to be
added to the inner subscriptions list. This Subscription can be used with
remove() to remove the passed teardown logic from the inner subscriptions
list.
The Observer callback to receive a valueless notification of type
complete from the Observable. Notifies the Observer that the Observable
has finished sending push-based notifications.
The Observer callback to receive notifications of type next from
the Observable, with a value. The Observable may call this method 0 or more
times.
Removes a Subscription from the internal list of subscriptions that will unsubscribe during the unsubscribe process of this Subscription.
The subscription to remove.
A static factory for a Subscriber, given a (potentially partial) definition of an Observer.
A Subscriber wrapping the (partially defined) Observer represented by the given arguments.
Projects each source value to the same Observable which is flattened multiple times with switch in the output Observable.
It's like switchMap, but maps each value always to the same inner Observable.

Maps each source value to the given Observable innerObservable regardless
of the source value, and then flattens those resulting Observables into one
single Observable, which is the output Observable. The output Observables
emits values only from the most recently emitted instance of
innerObservable.
An Observable to replace each value from the source Observable.
An Observable that emits items from the given
innerObservable every time a value is emitted on the source Observable.
We need this JSDoc comment for affecting ESDoc.
A flag to indicate whether this Subscription has already been unsubscribed.
Adds a tear down to be called during the unsubscribe() of this Subscription.
If the tear down being added is a subscription that is already
unsubscribed, is the same reference add is being called on, or is
Subscription.EMPTY, it will not be added.
If this subscription is already in an isUnsubscribed state, the passed
tear down logic will be executed immediately.
The additional logic to execute on teardown.
Returns the Subscription used or created to be
added to the inner subscriptions list. This Subscription can be used with
remove() to remove the passed teardown logic from the inner subscriptions
list.
The Observer callback to receive a valueless notification of type
complete from the Observable. Notifies the Observer that the Observable
has finished sending push-based notifications.
The Observer callback to receive notifications of type next from
the Observable, with a value. The Observable may call this method 0 or more
times.
Removes a Subscription from the internal list of subscriptions that will unsubscribe during the unsubscribe process of this Subscription.
The subscription to remove.
A static factory for a Subscriber, given a (potentially partial) definition of an Observer.
A Subscriber wrapping the (partially defined) Observer represented by the given arguments.
We need this JSDoc comment for affecting ESDoc.
A flag to indicate whether this Subscription has already been unsubscribed.
Adds a tear down to be called during the unsubscribe() of this Subscription.
If the tear down being added is a subscription that is already
unsubscribed, is the same reference add is being called on, or is
Subscription.EMPTY, it will not be added.
If this subscription is already in an isUnsubscribed state, the passed
tear down logic will be executed immediately.
The additional logic to execute on teardown.
Returns the Subscription used or created to be
added to the inner subscriptions list. This Subscription can be used with
remove() to remove the passed teardown logic from the inner subscriptions
list.
The Observer callback to receive a valueless notification of type
complete from the Observable. Notifies the Observer that the Observable
has finished sending push-based notifications.
The Observer callback to receive notifications of type next from
the Observable, with a value. The Observable may call this method 0 or more
times.
Removes a Subscription from the internal list of subscriptions that will unsubscribe during the unsubscribe process of this Subscription.
The subscription to remove.
A static factory for a Subscriber, given a (potentially partial) definition of an Observer.
A Subscriber wrapping the (partially defined) Observer represented by the given arguments.
We need this JSDoc comment for affecting ESDoc.
A flag to indicate whether this Subscription has already been unsubscribed.
Adds a tear down to be called during the unsubscribe() of this Subscription.
If the tear down being added is a subscription that is already
unsubscribed, is the same reference add is being called on, or is
Subscription.EMPTY, it will not be added.
If this subscription is already in an isUnsubscribed state, the passed
tear down logic will be executed immediately.
The additional logic to execute on teardown.
Returns the Subscription used or created to be
added to the inner subscriptions list. This Subscription can be used with
remove() to remove the passed teardown logic from the inner subscriptions
list.
The Observer callback to receive a valueless notification of type
complete from the Observable. Notifies the Observer that the Observable
has finished sending push-based notifications.
The Observer callback to receive notifications of type next from
the Observable, with a value. The Observable may call this method 0 or more
times.
Removes a Subscription from the internal list of subscriptions that will unsubscribe during the unsubscribe process of this Subscription.
The subscription to remove.
A static factory for a Subscriber, given a (potentially partial) definition of an Observer.
A Subscriber wrapping the (partially defined) Observer represented by the given arguments.
We need this JSDoc comment for affecting ESDoc.
A flag to indicate whether this Subscription has already been unsubscribed.
Adds a tear down to be called during the unsubscribe() of this Subscription.
If the tear down being added is a subscription that is already
unsubscribed, is the same reference add is being called on, or is
Subscription.EMPTY, it will not be added.
If this subscription is already in an isUnsubscribed state, the passed
tear down logic will be executed immediately.
The additional logic to execute on teardown.
Returns the Subscription used or created to be
added to the inner subscriptions list. This Subscription can be used with
remove() to remove the passed teardown logic from the inner subscriptions
list.
The Observer callback to receive a valueless notification of type
complete from the Observable. Notifies the Observer that the Observable
has finished sending push-based notifications.
The Observer callback to receive notifications of type next from
the Observable, with a value. The Observable may call this method 0 or more
times.
Removes a Subscription from the internal list of subscriptions that will unsubscribe during the unsubscribe process of this Subscription.
The subscription to remove.
A static factory for a Subscriber, given a (potentially partial) definition of an Observer.
A Subscriber wrapping the (partially defined) Observer represented by the given arguments.
We need this JSDoc comment for affecting ESDoc.
A flag to indicate whether this Subscription has already been unsubscribed.
Adds a tear down to be called during the unsubscribe() of this Subscription.
If the tear down being added is a subscription that is already
unsubscribed, is the same reference add is being called on, or is
Subscription.EMPTY, it will not be added.
If this subscription is already in an isUnsubscribed state, the passed
tear down logic will be executed immediately.
The additional logic to execute on teardown.
Returns the Subscription used or created to be
added to the inner subscriptions list. This Subscription can be used with
remove() to remove the passed teardown logic from the inner subscriptions
list.
The Observer callback to receive a valueless notification of type
complete from the Observable. Notifies the Observer that the Observable
has finished sending push-based notifications.
The Observer callback to receive notifications of type next from
the Observable, with a value. The Observable may call this method 0 or more
times.
Removes a Subscription from the internal list of subscriptions that will unsubscribe during the unsubscribe process of this Subscription.
The subscription to remove.
A static factory for a Subscriber, given a (potentially partial) definition of an Observer.
A Subscriber wrapping the (partially defined) Observer represented by the given arguments.
We need this JSDoc comment for affecting ESDoc.
A flag to indicate whether this Subscription has already been unsubscribed.
Adds a tear down to be called during the unsubscribe() of this Subscription.
If the tear down being added is a subscription that is already
unsubscribed, is the same reference add is being called on, or is
Subscription.EMPTY, it will not be added.
If this subscription is already in an isUnsubscribed state, the passed
tear down logic will be executed immediately.
The additional logic to execute on teardown.
Returns the Subscription used or created to be
added to the inner subscriptions list. This Subscription can be used with
remove() to remove the passed teardown logic from the inner subscriptions
list.
The Observer callback to receive a valueless notification of type
complete from the Observable. Notifies the Observer that the Observable
has finished sending push-based notifications.
The Observer callback to receive notifications of type next from
the Observable, with a value. The Observable may call this method 0 or more
times.
Removes a Subscription from the internal list of subscriptions that will unsubscribe during the unsubscribe process of this Subscription.
The subscription to remove.
A static factory for a Subscriber, given a (potentially partial) definition of an Observer.
A Subscriber wrapping the (partially defined) Observer represented by the given arguments.
We need this JSDoc comment for affecting ESDoc.
A flag to indicate whether this Subscription has already been unsubscribed.
Adds a tear down to be called during the unsubscribe() of this Subscription.
If the tear down being added is a subscription that is already
unsubscribed, is the same reference add is being called on, or is
Subscription.EMPTY, it will not be added.
If this subscription is already in an isUnsubscribed state, the passed
tear down logic will be executed immediately.
The additional logic to execute on teardown.
Returns the Subscription used or created to be
added to the inner subscriptions list. This Subscription can be used with
remove() to remove the passed teardown logic from the inner subscriptions
list.
The Observer callback to receive a valueless notification of type
complete from the Observable. Notifies the Observer that the Observable
has finished sending push-based notifications.
The Observer callback to receive notifications of type next from
the Observable, with a value. The Observable may call this method 0 or more
times.
Removes a Subscription from the internal list of subscriptions that will unsubscribe during the unsubscribe process of this Subscription.
The subscription to remove.
A static factory for a Subscriber, given a (potentially partial) definition of an Observer.
A Subscriber wrapping the (partially defined) Observer represented by the given arguments.
We need this JSDoc comment for affecting ESDoc.
A flag to indicate whether this Subscription has already been unsubscribed.
Adds a tear down to be called during the unsubscribe() of this Subscription.
If the tear down being added is a subscription that is already
unsubscribed, is the same reference add is being called on, or is
Subscription.EMPTY, it will not be added.
If this subscription is already in an isUnsubscribed state, the passed
tear down logic will be executed immediately.
The additional logic to execute on teardown.
Returns the Subscription used or created to be
added to the inner subscriptions list. This Subscription can be used with
remove() to remove the passed teardown logic from the inner subscriptions
list.
The Observer callback to receive a valueless notification of type
complete from the Observable. Notifies the Observer that the Observable
has finished sending push-based notifications.
The Observer callback to receive notifications of type next from
the Observable, with a value. The Observable may call this method 0 or more
times.
Removes a Subscription from the internal list of subscriptions that will unsubscribe during the unsubscribe process of this Subscription.
The subscription to remove.
A static factory for a Subscriber, given a (potentially partial) definition of an Observer.
A Subscriber wrapping the (partially defined) Observer represented by the given arguments.
We need this JSDoc comment for affecting ESDoc.
A flag to indicate whether this Subscription has already been unsubscribed.
Adds a tear down to be called during the unsubscribe() of this Subscription.
If the tear down being added is a subscription that is already
unsubscribed, is the same reference add is being called on, or is
Subscription.EMPTY, it will not be added.
If this subscription is already in an isUnsubscribed state, the passed
tear down logic will be executed immediately.
The additional logic to execute on teardown.
Returns the Subscription used or created to be
added to the inner subscriptions list. This Subscription can be used with
remove() to remove the passed teardown logic from the inner subscriptions
list.
The Observer callback to receive a valueless notification of type
complete from the Observable. Notifies the Observer that the Observable
has finished sending push-based notifications.
The Observer callback to receive notifications of type next from
the Observable, with a value. The Observable may call this method 0 or more
times.
Removes a Subscription from the internal list of subscriptions that will unsubscribe during the unsubscribe process of this Subscription.
The subscription to remove.
A static factory for a Subscriber, given a (potentially partial) definition of an Observer.
A Subscriber wrapping the (partially defined) Observer represented by the given arguments.
A flag to indicate whether this Subscription has already been unsubscribed.
Adds a tear down to be called during the unsubscribe() of this Subscription.
If the tear down being added is a subscription that is already
unsubscribed, is the same reference add is being called on, or is
Subscription.EMPTY, it will not be added.
If this subscription is already in an isUnsubscribed state, the passed
tear down logic will be executed immediately.
The additional logic to execute on teardown.
Returns the Subscription used or created to be
added to the inner subscriptions list. This Subscription can be used with
remove() to remove the passed teardown logic from the inner subscriptions
list.
The Observer callback to receive a valueless notification of type
complete from the Observable. Notifies the Observer that the Observable
has finished sending push-based notifications.
The Observer callback to receive notifications of type next from
the Observable, with a value. The Observable may call this method 0 or more
times.
Removes a Subscription from the internal list of subscriptions that will unsubscribe during the unsubscribe process of this Subscription.
The subscription to remove.
A static factory for a Subscriber, given a (potentially partial) definition of an Observer.
A Subscriber wrapping the (partially defined) Observer represented by the given arguments.
We need this JSDoc comment for affecting ESDoc.
A flag to indicate whether this Subscription has already been unsubscribed.
Adds a tear down to be called during the unsubscribe() of this Subscription.
If the tear down being added is a subscription that is already
unsubscribed, is the same reference add is being called on, or is
Subscription.EMPTY, it will not be added.
If this subscription is already in an isUnsubscribed state, the passed
tear down logic will be executed immediately.
The additional logic to execute on teardown.
Returns the Subscription used or created to be
added to the inner subscriptions list. This Subscription can be used with
remove() to remove the passed teardown logic from the inner subscriptions
list.
The Observer callback to receive a valueless notification of type
complete from the Observable. Notifies the Observer that the Observable
has finished sending push-based notifications.
The Observer callback to receive notifications of type next from
the Observable, with a value. The Observable may call this method 0 or more
times.
Removes a Subscription from the internal list of subscriptions that will unsubscribe during the unsubscribe process of this Subscription.
The subscription to remove.
A static factory for a Subscriber, given a (potentially partial) definition of an Observer.
A Subscriber wrapping the (partially defined) Observer represented by the given arguments.
We need this JSDoc comment for affecting ESDoc.
A flag to indicate whether this Subscription has already been unsubscribed.
Adds a tear down to be called during the unsubscribe() of this Subscription.
If the tear down being added is a subscription that is already
unsubscribed, is the same reference add is being called on, or is
Subscription.EMPTY, it will not be added.
If this subscription is already in an isUnsubscribed state, the passed
tear down logic will be executed immediately.
The additional logic to execute on teardown.
Returns the Subscription used or created to be
added to the inner subscriptions list. This Subscription can be used with
remove() to remove the passed teardown logic from the inner subscriptions
list.
The Observer callback to receive a valueless notification of type
complete from the Observable. Notifies the Observer that the Observable
has finished sending push-based notifications.
The Observer callback to receive notifications of type next from
the Observable, with a value. The Observable may call this method 0 or more
times.
Removes a Subscription from the internal list of subscriptions that will unsubscribe during the unsubscribe process of this Subscription.
The subscription to remove.
A static factory for a Subscriber, given a (potentially partial) definition of an Observer.
A Subscriber wrapping the (partially defined) Observer represented by the given arguments.
Branch out the source Observable values as a nested Observable whenever
windowBoundaries emits.
It's like buffer, but emits a nested Observable instead of an array.

Returns an Observable that emits windows of items it collects from the source
Observable. The output Observable emits connected, non-overlapping
windows. It emits the current window and opens a new one whenever the
Observable windowBoundaries emits an item. Because each window is an
Observable, the output is a higher-order Observable.
An Observable that completes the previous window and starts a new window.
An Observable of windows, which are Observables emitting values of the source Observable.
We need this JSDoc comment for affecting ESDoc.
A flag to indicate whether this Subscription has already been unsubscribed.
Adds a tear down to be called during the unsubscribe() of this Subscription.
If the tear down being added is a subscription that is already
unsubscribed, is the same reference add is being called on, or is
Subscription.EMPTY, it will not be added.
If this subscription is already in an isUnsubscribed state, the passed
tear down logic will be executed immediately.
The additional logic to execute on teardown.
Returns the Subscription used or created to be
added to the inner subscriptions list. This Subscription can be used with
remove() to remove the passed teardown logic from the inner subscriptions
list.
The Observer callback to receive a valueless notification of type
complete from the Observable. Notifies the Observer that the Observable
has finished sending push-based notifications.
The Observer callback to receive notifications of type next from
the Observable, with a value. The Observable may call this method 0 or more
times.
Removes a Subscription from the internal list of subscriptions that will unsubscribe during the unsubscribe process of this Subscription.
The subscription to remove.
A static factory for a Subscriber, given a (potentially partial) definition of an Observer.
A Subscriber wrapping the (partially defined) Observer represented by the given arguments.
Branch out the source Observable values as a nested Observable with each
nested Observable emitting at most windowSize values.
It's like bufferCount, but emits a nested Observable instead of an array.

Returns an Observable that emits windows of items it collects from the source
Observable. The output Observable emits windows every startWindowEvery
items, each containing no more than windowSize items. When the source
Observable completes or encounters an error, the output Observable emits
the current window and propagates the notification from the source
Observable. If startWindowEvery is not provided, then new windows are
started immediately at the start of the source and when each window completes
with size windowSize.
The maximum number of values emitted by each window.
An Observable of windows, which in turn are Observable of values.
We need this JSDoc comment for affecting ESDoc.
A flag to indicate whether this Subscription has already been unsubscribed.
Adds a tear down to be called during the unsubscribe() of this Subscription.
If the tear down being added is a subscription that is already
unsubscribed, is the same reference add is being called on, or is
Subscription.EMPTY, it will not be added.
If this subscription is already in an isUnsubscribed state, the passed
tear down logic will be executed immediately.
The additional logic to execute on teardown.
Returns the Subscription used or created to be
added to the inner subscriptions list. This Subscription can be used with
remove() to remove the passed teardown logic from the inner subscriptions
list.
The Observer callback to receive a valueless notification of type
complete from the Observable. Notifies the Observer that the Observable
has finished sending push-based notifications.
The Observer callback to receive notifications of type next from
the Observable, with a value. The Observable may call this method 0 or more
times.
Removes a Subscription from the internal list of subscriptions that will unsubscribe during the unsubscribe process of this Subscription.
The subscription to remove.
A static factory for a Subscriber, given a (potentially partial) definition of an Observer.
A Subscriber wrapping the (partially defined) Observer represented by the given arguments.
Branch out the source Observable values as a nested Observable periodically in time.
It's like bufferTime, but emits a nested Observable instead of an array.

Returns an Observable that emits windows of items it collects from the source
Observable. The output Observable starts a new window periodically, as
determined by the windowCreationInterval argument. It emits each window
after a fixed timespan, specified by the windowTimeSpan argument. When the
source Observable completes or encounters an error, the output Observable
emits the current window and propagates the notification from the source
Observable. If windowCreationInterval is not provided, the output
Observable starts a new window when the previous window of duration
windowTimeSpan completes.
The amount of time to fill each window.
An observable of windows, which in turn are Observables.
We need this JSDoc comment for affecting ESDoc.
A flag to indicate whether this Subscription has already been unsubscribed.
Adds a tear down to be called during the unsubscribe() of this Subscription.
If the tear down being added is a subscription that is already
unsubscribed, is the same reference add is being called on, or is
Subscription.EMPTY, it will not be added.
If this subscription is already in an isUnsubscribed state, the passed
tear down logic will be executed immediately.
The additional logic to execute on teardown.
Returns the Subscription used or created to be
added to the inner subscriptions list. This Subscription can be used with
remove() to remove the passed teardown logic from the inner subscriptions
list.
The Observer callback to receive a valueless notification of type
complete from the Observable. Notifies the Observer that the Observable
has finished sending push-based notifications.
The Observer callback to receive notifications of type next from
the Observable, with a value. The Observable may call this method 0 or more
times.
Removes a Subscription from the internal list of subscriptions that will unsubscribe during the unsubscribe process of this Subscription.
The subscription to remove.
A static factory for a Subscriber, given a (potentially partial) definition of an Observer.
A Subscriber wrapping the (partially defined) Observer represented by the given arguments.
Branch out the source Observable values as a nested Observable starting from
an emission from openings and ending when the output of closingSelector
emits.
It's like bufferToggle, but emits a nested Observable instead of an array.

Returns an Observable that emits windows of items it collects from the source
Observable. The output Observable emits windows that contain those items
emitted by the source Observable between the time when the openings
Observable emits an item and when the Observable returned by
closingSelector emits an item.
An observable of notifications to start new windows.
A function that takes
the value emitted by the openings observable and returns an Observable,
which, when it emits (either next or complete), signals that the
associated window should complete.
An observable of windows, which in turn are Observables.
We need this JSDoc comment for affecting ESDoc.
A flag to indicate whether this Subscription has already been unsubscribed.
Adds a tear down to be called during the unsubscribe() of this Subscription.
If the tear down being added is a subscription that is already
unsubscribed, is the same reference add is being called on, or is
Subscription.EMPTY, it will not be added.
If this subscription is already in an isUnsubscribed state, the passed
tear down logic will be executed immediately.
The additional logic to execute on teardown.
Returns the Subscription used or created to be
added to the inner subscriptions list. This Subscription can be used with
remove() to remove the passed teardown logic from the inner subscriptions
list.
The Observer callback to receive a valueless notification of type
complete from the Observable. Notifies the Observer that the Observable
has finished sending push-based notifications.
The Observer callback to receive notifications of type next from
the Observable, with a value. The Observable may call this method 0 or more
times.
Removes a Subscription from the internal list of subscriptions that will unsubscribe during the unsubscribe process of this Subscription.
The subscription to remove.
A static factory for a Subscriber, given a (potentially partial) definition of an Observer.
A Subscriber wrapping the (partially defined) Observer represented by the given arguments.
Branch out the source Observable values as a nested Observable using a factory function of closing Observables to determine when to start a new window.
It's like bufferWhen, but emits a nested Observable instead of an array.

Returns an Observable that emits windows of items it collects from the source
Observable. The output Observable emits connected, non-overlapping windows.
It emits the current window and opens a new one whenever the Observable
produced by the specified closingSelector function emits an item. The first
window is opened immediately when subscribing to the output Observable.
A function that takes no
arguments and returns an Observable that signals (on either next or
complete) when to close the previous window and start a new one.
An observable of windows, which in turn are Observables.
We need this JSDoc comment for affecting ESDoc.
A flag to indicate whether this Subscription has already been unsubscribed.
Adds a tear down to be called during the unsubscribe() of this Subscription.
If the tear down being added is a subscription that is already
unsubscribed, is the same reference add is being called on, or is
Subscription.EMPTY, it will not be added.
If this subscription is already in an isUnsubscribed state, the passed
tear down logic will be executed immediately.
The additional logic to execute on teardown.
Returns the Subscription used or created to be
added to the inner subscriptions list. This Subscription can be used with
remove() to remove the passed teardown logic from the inner subscriptions
list.
The Observer callback to receive a valueless notification of type
complete from the Observable. Notifies the Observer that the Observable
has finished sending push-based notifications.
The Observer callback to receive notifications of type next from
the Observable, with a value. The Observable may call this method 0 or more
times.
Removes a Subscription from the internal list of subscriptions that will unsubscribe during the unsubscribe process of this Subscription.
The subscription to remove.
A static factory for a Subscriber, given a (potentially partial) definition of an Observer.
A Subscriber wrapping the (partially defined) Observer represented by the given arguments.
Combines the source Observable with other Observables to create an Observable whose values are calculated from the latest values of each, only when the source emits.
Whenever the source Observable emits a value, it computes a formula using that value plus the latest values from other input Observables, then emits the output of that formula.

withLatestFrom combines each value from the source Observable (the
instance) with the latest values from the other input Observables only when
the source emits a value, optionally using a project function to determine
the value to be emitted on the output Observable. All input Observables must
emit at least one value before the output Observable will emit a value.
An Observable of projected values from the most recent values from each input Observable, or an array of the most recent values from each input Observable.
We need this JSDoc comment for affecting ESDoc.
A flag to indicate whether this Subscription has already been unsubscribed.
Adds a tear down to be called during the unsubscribe() of this Subscription.
If the tear down being added is a subscription that is already
unsubscribed, is the same reference add is being called on, or is
Subscription.EMPTY, it will not be added.
If this subscription is already in an isUnsubscribed state, the passed
tear down logic will be executed immediately.
The additional logic to execute on teardown.
Returns the Subscription used or created to be
added to the inner subscriptions list. This Subscription can be used with
remove() to remove the passed teardown logic from the inner subscriptions
list.
The Observer callback to receive a valueless notification of type
complete from the Observable. Notifies the Observer that the Observable
has finished sending push-based notifications.
Removes a Subscription from the internal list of subscriptions that will unsubscribe during the unsubscribe process of this Subscription.
The subscription to remove.
A static factory for a Subscriber, given a (potentially partial) definition of an Observer.
A Subscriber wrapping the (partially defined) Observer represented by the given arguments.
We need this JSDoc comment for affecting ESDoc.
A flag to indicate whether this Subscription has already been unsubscribed.
Adds a tear down to be called during the unsubscribe() of this Subscription.
If the tear down being added is a subscription that is already
unsubscribed, is the same reference add is being called on, or is
Subscription.EMPTY, it will not be added.
If this subscription is already in an isUnsubscribed state, the passed
tear down logic will be executed immediately.
The additional logic to execute on teardown.
Returns the Subscription used or created to be
added to the inner subscriptions list. This Subscription can be used with
remove() to remove the passed teardown logic from the inner subscriptions
list.
The Observer callback to receive a valueless notification of type
complete from the Observable. Notifies the Observer that the Observable
has finished sending push-based notifications.
The Observer callback to receive notifications of type next from
the Observable, with a value. The Observable may call this method 0 or more
times.
Removes a Subscription from the internal list of subscriptions that will unsubscribe during the unsubscribe process of this Subscription.
The subscription to remove.
A static factory for a Subscriber, given a (potentially partial) definition of an Observer.
A Subscriber wrapping the (partially defined) Observer represented by the given arguments.
A flag to indicate whether this Subscription has already been unsubscribed.
Adds a tear down to be called during the unsubscribe() of this Subscription.
If the tear down being added is a subscription that is already
unsubscribed, is the same reference add is being called on, or is
Subscription.EMPTY, it will not be added.
If this subscription is already in an isUnsubscribed state, the passed
tear down logic will be executed immediately.
The additional logic to execute on teardown.
Returns the Subscription used or created to be
added to the inner subscriptions list. This Subscription can be used with
remove() to remove the passed teardown logic from the inner subscriptions
list.
Removes a Subscription from the internal list of subscriptions that will unsubscribe during the unsubscribe process of this Subscription.
The subscription to remove.
Disposes the resources held by the subscription. May, for instance, cancel an ongoing Observable execution or cancel any other type of work that started when the Subscription was created.
We need this JSDoc comment for affecting ESDoc.
A flag to indicate whether this Subscription has already been unsubscribed.
Adds a tear down to be called during the unsubscribe() of this Subscription.
If the tear down being added is a subscription that is already
unsubscribed, is the same reference add is being called on, or is
Subscription.EMPTY, it will not be added.
If this subscription is already in an isUnsubscribed state, the passed
tear down logic will be executed immediately.
The additional logic to execute on teardown.
Returns the Subscription used or created to be
added to the inner subscriptions list. This Subscription can be used with
remove() to remove the passed teardown logic from the inner subscriptions
list.
Removes a Subscription from the internal list of subscriptions that will unsubscribe during the unsubscribe process of this Subscription.
The subscription to remove.
Disposes the resources held by the subscription. May, for instance, cancel an ongoing Observable execution or cancel any other type of work that started when the Subscription was created.
We need this JSDoc comment for affecting ESDoc.
A flag to indicate whether this Subscription has already been unsubscribed.
Adds a tear down to be called during the unsubscribe() of this Subscription.
If the tear down being added is a subscription that is already
unsubscribed, is the same reference add is being called on, or is
Subscription.EMPTY, it will not be added.
If this subscription is already in an isUnsubscribed state, the passed
tear down logic will be executed immediately.
The additional logic to execute on teardown.
Returns the Subscription used or created to be
added to the inner subscriptions list. This Subscription can be used with
remove() to remove the passed teardown logic from the inner subscriptions
list.
Removes a Subscription from the internal list of subscriptions that will unsubscribe during the unsubscribe process of this Subscription.
The subscription to remove.
Disposes the resources held by the subscription. May, for instance, cancel an ongoing Observable execution or cancel any other type of work that started when the Subscription was created.
We need this JSDoc comment for affecting ESDoc.
A flag to indicate whether this Subscription has already been unsubscribed.
Adds a tear down to be called during the unsubscribe() of this Subscription.
If the tear down being added is a subscription that is already
unsubscribed, is the same reference add is being called on, or is
Subscription.EMPTY, it will not be added.
If this subscription is already in an isUnsubscribed state, the passed
tear down logic will be executed immediately.
The additional logic to execute on teardown.
Returns the Subscription used or created to be
added to the inner subscriptions list. This Subscription can be used with
remove() to remove the passed teardown logic from the inner subscriptions
list.
Removes a Subscription from the internal list of subscriptions that will unsubscribe during the unsubscribe process of this Subscription.
The subscription to remove.
Disposes the resources held by the subscription. May, for instance, cancel an ongoing Observable execution or cancel any other type of work that started when the Subscription was created.
A unit of work to be executed in a Scheduler. An action is typically created from within a Scheduler and an RxJS user does not need to concern themselves about creating and manipulating an Action.
interface Action extends Subscription {
work: (state?: any) => void|Subscription;
state?: any;
delay?: number;
schedule(state?: any, delay?: number): void;
execute(): void;
scheduler: Scheduler;
error: any;
}
Represents the time (relative to the Scheduler's own clock) when this action should be executed.
A reference to the latest error that may have occurred during action execution.
A flag to indicate whether this Subscription has already been unsubscribed.
The Scheduler which owns this action.
The current state. This is the object that will be given to the work
method.
Adds a tear down to be called during the unsubscribe() of this Subscription.
If the tear down being added is a subscription that is already
unsubscribed, is the same reference add is being called on, or is
Subscription.EMPTY, it will not be added.
If this subscription is already in an isUnsubscribed state, the passed
tear down logic will be executed immediately.
The additional logic to execute on teardown.
Returns the Subscription used or created to be
added to the inner subscriptions list. This Subscription can be used with
remove() to remove the passed teardown logic from the inner subscriptions
list.
Immediately executes this action and the work it contains.
Removes a Subscription from the internal list of subscriptions that will unsubscribe during the unsubscribe process of this Subscription.
The subscription to remove.
Schedules this action on its parent Scheduler for execution. May be passed
some context object, state. May happen at some point in the future,
according to the delay parameter, if specified.
Disposes the resources held by the subscription. May, for instance, cancel an ongoing Observable execution or cancel any other type of work that started when the Subscription was created.
The function that represents the raw work to be executed on a Scheduler.
A subscription in order to be able to unsubscribe the scheduled work.
We need this JSDoc comment for affecting ESDoc.
A flag to indicate whether this Subscription has already been unsubscribed.
Adds a tear down to be called during the unsubscribe() of this Subscription.
If the tear down being added is a subscription that is already
unsubscribed, is the same reference add is being called on, or is
Subscription.EMPTY, it will not be added.
If this subscription is already in an isUnsubscribed state, the passed
tear down logic will be executed immediately.
The additional logic to execute on teardown.
Returns the Subscription used or created to be
added to the inner subscriptions list. This Subscription can be used with
remove() to remove the passed teardown logic from the inner subscriptions
list.
Removes a Subscription from the internal list of subscriptions that will unsubscribe during the unsubscribe process of this Subscription.
The subscription to remove.
Disposes the resources held by the subscription. May, for instance, cancel an ongoing Observable execution or cancel any other type of work that started when the Subscription was created.
We need this JSDoc comment for affecting ESDoc.
A flag to indicate whether this Subscription has already been unsubscribed.
Adds a tear down to be called during the unsubscribe() of this Subscription.
If the tear down being added is a subscription that is already
unsubscribed, is the same reference add is being called on, or is
Subscription.EMPTY, it will not be added.
If this subscription is already in an isUnsubscribed state, the passed
tear down logic will be executed immediately.
The additional logic to execute on teardown.
Returns the Subscription used or created to be
added to the inner subscriptions list. This Subscription can be used with
remove() to remove the passed teardown logic from the inner subscriptions
list.
Removes a Subscription from the internal list of subscriptions that will unsubscribe during the unsubscribe process of this Subscription.
The subscription to remove.
We need this JSDoc comment for affecting ESDoc.
An interop point defined by the es7-observable spec https://github.com/zenparsing/es-observable
this instance of the observable
a handler for each value emitted by the observable
a promise that either resolves on observable completion or rejects with the handled error
Creates a new Observable, with this Observable as the source, and the passed operator defined as the new observable's operator.
the operator defining the operation to take on the observable
a new observable with the Operator applied
Registers handlers for handling emitted values, error and completions from the observable, and executes the observable's subscriber function, which will take action to set up the underlying data stream
(optional) either an observer defining all functions to be called, or the first of three possible handlers, which is the handler for each value emitted from the observable.
(optional) a handler for a terminal event resulting from an error. If no error handler is provided, the error will be thrown as unhandled
(optional) a handler for a terminal event resulting from successful completion.
a subscription reference to the registered handlers
Creates a new cold Observable by calling the Observable constructor
a new cold observable
We need this JSDoc comment for affecting ESDoc.
a handler for each value emitted by the observable
a promise that either resolves on observable completion or rejects with the handled error
Registers handlers for handling emitted values, error and completions from the observable, and executes the observable's subscriber function, which will take action to set up the underlying data stream
(optional) either an observer defining all functions to be called, or the first of three possible handlers, which is the handler for each value emitted from the observable.
(optional) a handler for a terminal event resulting from an error. If no error handler is provided, the error will be thrown as unhandled
(optional) a handler for a terminal event resulting from successful completion.
a subscription reference to the registered handlers
An error thrown when an element was queried at a certain index of an Observable, but no such index or position exists in that sequence.
An error thrown when an Observable or a sequence was queried but has no elements.
An error thrown when an action is invalid because the object has been unsubscribed.
An error thrown when one or more errors have occurred during the
unsubscribe of a Subscription.
Delay in milliseconds when the Task will run.
A periodic [MacroTask] is such which get automatically rescheduled after it is executed.
Delay in milliseconds when the Task will run.
A periodic [MacroTask] is such which get automatically rescheduled after it is executed.
Delay in milliseconds when the Task will run.
A periodic [MacroTask] is such which get automatically rescheduled after it is executed.
Suppress closure compiler errors about unknown 'process' variable
Function which needs to be executed by the Task after the [Zone.currentTask] has been set to the current task.
Represents the default work which needs to be done to un-schedule the Task from the VM. Not all Tasks are cancelable, and therefore this method is optional.
A zone may chose to intercept this function and perform its own scheduling.
Task specific options associated with the current task. This is passed to the scheduleFn.
The Function to be used by the VM on entering the [Task]. This function will delegate to
[Zone.runTask] and delegate to callback.
Number of times the task has been executed, or -1 if canceled.
Represents the default work which needs to be done to schedule the Task by the VM.
A zone may chose to intercept this function and perform its own scheduling.
Debug string representing the API which requested the scheduling of the task.
Task type: microTask, macroTask, eventTask.
Function which needs to be executed by the Task after the [Zone.currentTask] has been set to the current task.
Represents the default work which needs to be done to un-schedule the Task from the VM. Not all Tasks are cancelable, and therefore this method is optional.
A zone may chose to intercept this function and perform its own scheduling.
Task specific options associated with the current task. This is passed to the scheduleFn.
The Function to be used by the VM on entering the [Task]. This function will delegate to
[Zone.runTask] and delegate to callback.
Number of times the task has been executed, or -1 if canceled.
Represents the default work which needs to be done to schedule the Task by the VM.
A zone may chose to intercept this function and perform its own scheduling.
Debug string representing the API which requested the scheduling of the task.
Task type: microTask, macroTask, eventTask.
Function which needs to be executed by the Task after the [Zone.currentTask] has been set to the current task.
Represents the default work which needs to be done to un-schedule the Task from the VM. Not all Tasks are cancelable, and therefore this method is optional.
A zone may chose to intercept this function and perform its own scheduling.
Task specific options associated with the current task. This is passed to the scheduleFn.
The Function to be used by the VM on entering the [Task]. This function will delegate to
[Zone.runTask] and delegate to callback.
Number of times the task has been executed, or -1 if canceled.
Represents the default work which needs to be done to schedule the Task by the VM.
A zone may chose to intercept this function and perform its own scheduling.
Debug string representing the API which requested the scheduling of the task.
Task type: microTask, macroTask, eventTask.
Represents work which is executed with a clean stack.
Tasks are used in Zones to mark work which is performed on clean stack frame. There are three kinds of task. [MicroTask], [MacroTask], and [EventTask].
A JS VM can be modeled as a [MicroTask] queue, [MacroTask] queue, and [EventTask] set.
Function which needs to be executed by the Task after the [Zone.currentTask] has been set to the current task.
Represents the default work which needs to be done to un-schedule the Task from the VM. Not all Tasks are cancelable, and therefore this method is optional.
A zone may chose to intercept this function and perform its own scheduling.
Task specific options associated with the current task. This is passed to the scheduleFn.
The Function to be used by the VM on entering the [Task]. This function will delegate to
[Zone.runTask] and delegate to callback.
Number of times the task has been executed, or -1 if canceled.
Represents the default work which needs to be done to schedule the Task by the VM.
A zone may chose to intercept this function and perform its own scheduling.
Debug string representing the API which requested the scheduling of the task.
Task type: microTask, macroTask, eventTask.
Delay in milliseconds when the Task will run.
A periodic [MacroTask] is such which get automatically rescheduled after it is executed.
Zone is a mechanism for intercepting and keeping track of asynchronous work.
A Zone is a global object which is configured with rules about how to intercept and keep track of the asynchronous callbacks. Zone has these responsibilities:
A zone by itself does not do anything, instead it relies on some other code to route existing platform API through it. (The zone library ships with code which monkey patches all of the browsers's asynchronous API and redirects them through the zone for interception.)
In its simplest form a zone allows one to intercept the scheduling and calling of asynchronous operations, and execute additional code before as well as after the asynchronous task. The rules of interception are configured using [ZoneConfig]. There can be many different zone instances in a system, but only one zone is active at any given time which can be retrieved using [Zone#current].
An important aspect of the zones is that they should persist across asynchronous operations. To
achieve this, when a future work is scheduled through async API, it is necessary to capture, and
subsequently restore the current zone. For example if a code is running in zone b and it
invokes setTimeout to scheduleTask work later, the setTimeout method needs to 1) capture the
current zone and 2) wrap the wrapCallback in code which will restore the current zone b once
the wrapCallback executes. In this way the rules which govern the current code are preserved in
all future asynchronous tasks. There could be a different zone c which has different rules and
is associated with different asynchronous tasks. As these tasks are processed, each asynchronous
wrapCallback correctly restores the correct zone, as well as preserves the zone for future
asynchronous callbacks.
Example: Suppose a browser page consist of application code as well as third-party
advertisement code. (These two code bases are independent, developed by different mutually
unaware developers.) The application code may be interested in doing global error handling and
so it configures the app zone to send all of the errors to the server for analysis, and then
executes the application in the app zone. The advertising code is interested in the same
error processing but it needs to send the errors to a different third-party. So it creates the
ads zone with a different error handler. Now both advertising as well as application code
create many asynchronous operations, but the [Zone] will ensure that all of the asynchronous
operations created from the application code will execute in app zone with its error
handler and all of the advertisement code will execute in the ads zone with its error handler.
This will not only work for the async operations created directly, but also for all subsequent
asynchronous operations.
If you think of chain of asynchronous operations as a thread of execution (bit of a stretch) then [Zone#current] will act as a thread local variable.
In addition to wrapping the callbacks to restore the zone, all operations which cause a
scheduling of work for later are routed through the current zone which is allowed to intercept
them by adding work before or after the wrapCallback as well as using different means of
achieving the request. (Useful for unit testing, or tracking of requests). In some instances
such as setTimeout the wrapping of the wrapCallback and scheduling is done in the same
wrapCallback, but there are other examples such as Promises where the then wrapCallback is
wrapped, but the execution of then in triggered by Promise scheduling resolve work.
Fundamentally there are three kinds of tasks which can be scheduled:
setTimeout. This is typically cancelable
which is guaranteed to execute at least once after some well understood delay.Each asynchronous API is modeled and routed through one of these APIs.
[MicroTask]s represent work which will be done in current VM turn as soon as possible, before VM yielding.
[TimerTask]s represents work which will be done after some delay. (Sometimes the delay is
approximate such as on next available animation frame). Typically these methods include:
setTimeout, setImmediate, setInterval, requestAnimationFrame, and all browser specif
variants.
[EventTask]s represents a request to create a listener on an event. Unlike the other task events may never be executed, but typically execute more then once. There is no queue of events, rather their callbacks are unpredictable both in order and time.
Zones can be composed together through [Zone.fork()]. A child zone may create its own set of rules. A child zone is expected to either:
Composability allows zones to keep their concerns clean. For example a top most zone may chose to handle error handling, while child zones may chose to do user action tracking.
At the start the browser will run in a special root zone, which is configure to behave exactly like the platform, making any existing code which is not-zone aware behave as expected. All zones are children of the root zone.
Allows the zone to intercept canceling of scheduled Task.
The interception is configured using [ZoneSpec.onCancelTask]. The default canceler invokes the [Task.cancelFn].
Used to create a child zone.
A set of rules which the child zone should follow.
A new child zone.
Returns a value associated with the key.
If the current zone does not have a key, the request is delegated to the parent zone. Use [ZoneSpec.properties] to configure the set of properties asseciated with the current zone.
The key to retrieve.
Tha value for the key, or undefined if not found.
Invokes a function in a given zone.
The invocation of callback can be intercepted be declaring [ZoneSpec.onInvoke].
The function to invoke.
A unique debug location of the API being invoked.
Value from the callback function.
Invokes a function in a given zone and catches any exceptions.
Any exceptions thrown will be forwarded to [Zone.HandleError].
The invocation of callback can be intercepted be declaring [ZoneSpec.onInvoke]. The
handling of exceptions can intercepted by declaring [ZoneSpec.handleError].
The function to invoke.
A unique debug location of the API being invoked.
Value from the callback function.
Execute the Task by restoring the [Zone.currentTask] in the Task's zone.
Wraps a callback function in a new function which will properly restore the current zone upon invocation.
The wrapped function will properly forward this as well as arguments to the callback.
Before the function is wrapped the zone can intercept the callback by declaring
[ZoneSpec.onIntercept].
the function which will be wrapped in the zone.
A unique debug location of the API being wrapped.
A function which will invoke the callback through [Zone.runGuarded].
A delegate when intercepting zone operations.
A ZoneDelegate is needed because a child zone can't simply invoke a method on a parent zone. For example a child zone wrap can't just call parent zone wrap. Doing so would create a callback which is bound to the parent zone. What we are interested is intercepting the callback before it is bound to any zone. Furthermore, we also need to pass the targetZone (zone which received the original request) to the delegate.
The ZoneDelegate methods mirror those of Zone with an addition of extra targetZone argument in the method signature. (The original Zone which received the request.) Some methods are renamed to prevent confusion, because they have slightly different semantics and arguments.
wrap => intercept: The wrap method delegates to intercept. The wrap method returns
a callback which will run in a given zone, where as intercept allows wrapping the callback
so that additional code can be run before and after, but does not associated the callback
with the zone.run => invoke: The run method delegates to invoke to perform the actual execution of
the callback. The run method switches to new zone; saves and restores the Zone.current;
and optionally performs error handling. The invoke is not responsible for error handling,
or zone management.
Not every method is usually overwritten in the child zone, for this reason the ZoneDelegate stores the closest zone which overwrites this behavior along with the closest ZoneSpec.
NOTE: We have tried to make this API analogous to Event bubbling with target and current properties.
Note: The ZoneDelegate treats ZoneSpec as class. This allows the ZoneSpec to use its this to
store internal state.
Provides a way to configure the interception of zone events.
Only the name property is required (all other are optional).
The name of the zone. Usefull when debugging Zones.
Allows interception of task cancelation.
Allows the interception of zone forking.
When the zone is being forked, the request is forwarded to this method for interception.
Allows interception of the error handling.
Notifies of changes to the task queue empty status.
Allows interception of the wrapping of the callback.
Allows interception of the callback invocation.
Allows interception of task scheduling.
A set of properties to be associated with Zone. Use [Zone.get] to retrive them.
Task type: microTask, macroTask, eventTask.
Generated using TypeDoc
An abstract class for handling cookies.